From Coq Require Import ssreflect ssrfun ssrbool.

From Ltac2 Require Import Ltac2 Control.

From Coq Require Import Ensembles Bool String.
From Coq.Logic Require Import FunctionalExtensionality Eqdep_dec.
From Equations Require Import Equations.

Require Import Coq.Program.Tactics.

From MatchingLogic Require Import
    Utils.extralibrary
    Logic
    DerivedOperators_Syntax
    ProofMode_base
    ProofInfo
    BasicProofSystemLemmas
.

From stdpp Require Import list tactics fin_sets coGset gmap sets.
New coercion path [Is_true] : bool >-> Sortclass is ambiguous with existing 
[is_true] : bool >-> Sortclass.
[ambiguous-paths,typechecker]
New coercion path [Is_true] : bool >-> Sortclass is ambiguous with existing 
[is_true] : bool >-> Sortclass.
[ambiguous-paths,typechecker]
New coercion path [Is_true] : bool >-> Sortclass is ambiguous with existing 
[is_true] : bool >-> Sortclass.
[ambiguous-paths,typechecker]
New coercion path [Is_true] : bool >-> Sortclass is ambiguous with existing 
[is_true] : bool >-> Sortclass.
[ambiguous-paths,typechecker]
New coercion path [Is_true] : bool >-> Sortclass is ambiguous with existing 
[is_true] : bool >-> Sortclass.
[ambiguous-paths,typechecker]
New coercion path [Is_true] : bool >-> Sortclass is ambiguous with existing 
[is_true] : bool >-> Sortclass.
[ambiguous-paths,typechecker]

From MatchingLogic.Utils Require Import stdpp_ext.

Import extralibrary.

Import
  MatchingLogic.Logic.Notations
  MatchingLogic.DerivedOperators_Syntax.Notations
.

Set Default Proof Mode "Classic".

Open Scope string_scope.
Open Scope list_scope.
Open Scope ml_scope.

Lemma MLGoal_exactn {Σ : Signature}
  (Γ : Theory)
  (l₁ l₂ : hypotheses)
  (name : string)
  (g : Pattern)
  (info : ProofInfo) :
  mkMLGoal Σ Γ (l₁ ++ (mkNH _ name g) :: l₂) g info.
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
Γ Ⱶ
l₁ ++ (name ∶ g) :: l₂--------------------------------------
g
using info

Proof.
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
Γ Ⱶ
l₁ ++ (name ∶ g) :: l₂--------------------------------------
g
using info

  mlExtractWF wfl₁gl₂ wfg.
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf
  (patterns_of (l₁ ++ (name ∶ g) :: l₂))
Γ Ⱶ
l₁ ++ (name ∶ g) :: l₂--------------------------------------
g
using info

  fromMLGoal.
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf
  (patterns_of (l₁ ++ (name ∶ g) :: l₂))
Γ
⊢i foldr patt_imp g
     (patterns_of (l₁ ++ (name ∶ g) :: l₂)) using info
  useBasicReasoning.
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf
  (patterns_of (l₁ ++ (name ∶ g) :: l₂))
Γ
⊢i foldr patt_imp g
     (patterns_of (l₁ ++ (name ∶ g) :: l₂))
using BasicReasoning
  unfold patterns_of in *.
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf
  (map nh_patt (l₁ ++ (name ∶ g) :: l₂))
Γ
⊢i foldr patt_imp g
     (map nh_patt (l₁ ++ (name ∶ g) :: l₂))
using BasicReasoning
  rewrite map_app.
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf
  (map nh_patt (l₁ ++ (name ∶ g) :: l₂))
Γ
⊢i foldr patt_imp g
     (map nh_patt l₁ ++ map nh_patt ((name ∶ g) :: l₂))
using BasicReasoning
  apply nested_const_middle.
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf
  (map nh_patt (l₁ ++ (name ∶ g) :: l₂))
well_formed (nh_patt (name ∶ g))
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf
  (map nh_patt (l₁ ++ (name ∶ g) :: l₂))
Pattern.wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf
  (map nh_patt (l₁ ++ (name ∶ g) :: l₂))
Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l₂)
  {
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf
  (map nh_patt (l₁ ++ (name ∶ g) :: l₂))
well_formed (nh_patt (name ∶ g)) exact wfg. }
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf
  (map nh_patt (l₁ ++ (name ∶ g) :: l₂))
Pattern.wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf
  (map nh_patt (l₁ ++ (name ∶ g) :: l₂))
Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l₂)
  {
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf
  (map nh_patt (l₁ ++ (name ∶ g) :: l₂))
Pattern.wf (map nh_patt l₁) abstract (
      pose proof (wfl₁ := wf_take (length (patterns_of l₁)) _ wfl₁gl₂);
      rewrite map_app in wfl₁;
      rewrite take_app in wfl₁;
      exact wfl₁
    ).
  }
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf
  (map nh_patt (l₁ ++ (name ∶ g) :: l₂))
Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l₂)
  {
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf
  (map nh_patt (l₁ ++ (name ∶ g) :: l₂))
Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l₂)
    abstract (
      pose proof (wfgl₂ := wf_drop (length (patterns_of l₁)) _ wfl₁gl₂);
      rewrite map_app in wfgl₂;
      rewrite drop_app in wfgl₂;
      unfold Pattern.wf in wfgl₂;
      simpl in wfgl₂;
      apply andb_prop in wfgl₂;
      destruct wfgl₂ as [_ wfl₂];
      exact wfl₂
    ).
  }
Defined.


Tactic Notation "mlExactn" constr(n) :=
  _ensureProofMode;
  _mlReshapeHypsByIdx n;
  apply MLGoal_exactn.



Lemma MLGoal_exact {Σ : Signature} Γ l name g idx info:
  find_hyp name l = Some (idx, (mkNH _ name g)) ->
  mkMLGoal Σ Γ l g info.
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g: Pattern
idx: nat
info: ProofInfo
find_hyp name l = Some (idx, name ∶ g)
→ Γ Ⱶ
l--------------------------------------
g
using info

Proof.
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g: Pattern
idx: nat
info: ProofInfo
find_hyp name l = Some (idx, name ∶ g)
→ Γ Ⱶ
l--------------------------------------
g
using info

  intros Hfound.
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g: Pattern
idx: nat
info: ProofInfo
Hfound: find_hyp name l = Some (idx, name ∶ g)
Γ Ⱶ
l--------------------------------------
g
using info

  setoid_rewrite -> list.list_find_Some in Hfound.
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g: Pattern
idx: nat
info: ProofInfo
Hfound: l !! idx = Some (name ∶ g)
∧ has_name name (name ∶ g)
  ∧ (∀ (j : nat) (y : named_hypothesis),
       l !! j = Some y
       → j < idx → ¬ has_name name y)
Γ Ⱶ
l--------------------------------------
g
using info

  destruct Hfound as [Hfound1 [Hfound2 Hfound3] ].
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g: Pattern
idx: nat
info: ProofInfo
Hfound1: l !! idx = Some (name ∶ g)
Hfound2: has_name name (name ∶ g)
Hfound3: ∀ (j : nat) (y : named_hypothesis),
  l !! j = Some y
  → j < idx → ¬ has_name name y
Γ Ⱶ
l--------------------------------------
g
using info

  rewrite -[l](take_drop_middle l idx (mkNH _ name g)).
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g: Pattern
idx: nat
info: ProofInfo
Hfound1: l !! idx = Some (name ∶ g)
Hfound2: has_name name (name ∶ g)
Hfound3: ∀ (j : nat) (y : named_hypothesis),
  l !! j = Some y
  → j < idx → ¬ has_name name y
l !! idx = Some (name ∶ g)
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g: Pattern
idx: nat
info: ProofInfo
Hfound1: l !! idx = Some (name ∶ g)
Hfound2: has_name name (name ∶ g)
Hfound3: ∀ (j : nat) (y : named_hypothesis),
  l !! j = Some y
  → j < idx → ¬ has_name name y
Γ Ⱶ
take idx l ++ (name ∶ g) :: drop (S idx) l--------------------------------------
g
using info

  {
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g: Pattern
idx: nat
info: ProofInfo
Hfound1: l !! idx = Some (name ∶ g)
Hfound2: has_name name (name ∶ g)
Hfound3: ∀ (j : nat) (y : named_hypothesis),
  l !! j = Some y
  → j < idx → ¬ has_name name y
l !! idx = Some (name ∶ g) exact Hfound1. }
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g: Pattern
idx: nat
info: ProofInfo
Hfound1: l !! idx = Some (name ∶ g)
Hfound2: has_name name (name ∶ g)
Hfound3: ∀ (j : nat) (y : named_hypothesis),
  l !! j = Some y
  → j < idx → ¬ has_name name y
Γ Ⱶ
take idx l ++ (name ∶ g) :: drop (S idx) l--------------------------------------
g
using info

  apply MLGoal_exactn.
Defined.

Tactic Notation "mlExact" constr(name')
:=
  _ensureProofMode;
  eapply MLGoal_exact with (name := name');
  simpl; apply f_equal; reflexivity
.

Local Example ex_mlExact {Σ : Signature} Γ a b c:
  well_formed a = true ->
  well_formed b = true ->
  well_formed c = true ->
  Γ ⊢i a ---> b ---> c ---> b using BasicReasoning.
Σ: Signature
Γ: Theory
a, b, c: Pattern
well_formed a = true
→ well_formed b = true
  → well_formed c = true
    → Γ ⊢i a ---> b ---> c ---> b using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
a, b, c: Pattern
well_formed a = true
→ well_formed b = true
  → well_formed c = true
    → Γ ⊢i a ---> b ---> c ---> b using BasicReasoning
  intros wfa wfb wfc.
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfc: well_formed c = true
Γ ⊢i a ---> b ---> c ---> b using BasicReasoning
  toMLGoal.
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfc: well_formed c = true
well_formed (a ---> b ---> c ---> b)
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfc: well_formed c = true
Γ Ⱶ
a ---> b ---> c ---> b
using BasicReasoning

  {
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfc: well_formed c = true
well_formed (a ---> b ---> c ---> b) wf_auto2. }
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfc: well_formed c = true
Γ Ⱶ
a ---> b ---> c ---> b
using BasicReasoning

  mlIntro "H1".
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfc: well_formed c = true
Γ Ⱶ
"H1" ∶ a,
--------------------------------------
b ---> c ---> b
using BasicReasoning
 mlIntro "H2".
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfc: well_formed c = true
Γ Ⱶ
"H1" ∶ a,
"H2" ∶ b,
--------------------------------------
c ---> b
using BasicReasoning
 mlIntro "H3". (* TODO: mlIntros "H1" "H2" "H3".*)
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfc: well_formed c = true
Γ Ⱶ
"H1" ∶ a,
"H2" ∶ b,
"H3" ∶ c,
--------------------------------------
b
using BasicReasoning

  mlExact "H2".
Defined.



Lemma MLGoal_weakenConclusion' {Σ : Signature} Γ l g g' (i : ProofInfo):
  Γ ⊢i g ---> g' using i ->
  mkMLGoal Σ Γ l g i ->
  mkMLGoal Σ Γ l g' i.
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Γ ⊢i g ---> g' using i
→ Γ Ⱶ
  l--------------------------------------
  g
  using i
  
  → Γ Ⱶ
  l--------------------------------------
  g'
  using i
  
Proof.
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Γ ⊢i g ---> g' using i
→ Γ Ⱶ
  l--------------------------------------
  g
  using i
  
  → Γ Ⱶ
  l--------------------------------------
  g'
  using i
  
  intros Hgg' Hlg.
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: Γ Ⱶ
l--------------------------------------
g
using i

Γ Ⱶ
l--------------------------------------
g'
using i

  (*mlExtractWF wfl wfgp.*)
  unfold of_MLGoal in *.
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed
  (mlConclusion
     (Γ Ⱶ
      l--------------------------------------
      g
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l--------------------------------------
           g
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       l--------------------------------------
       g
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l--------------------------------------
             g
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l--------------------------------------
                g
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             l--------------------------------------
             g
             using i
             )
well_formed
  (mlConclusion
     (Γ Ⱶ
      l--------------------------------------
      g'
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l--------------------------------------
           g'
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       l--------------------------------------
       g'
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l--------------------------------------
             g'
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l--------------------------------------
                g'
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             l--------------------------------------
             g'
             using i
             ) simpl in *.
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp g (patterns_of l)
    using i
well_formed g'
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp g' (patterns_of l) using i
  intros wfg' wfl.
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp g (patterns_of l)
    using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp g' (patterns_of l) using i
  pose proof (wfimp := proved_impl_wf _ _ (proj1_sig Hgg')).
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp g (patterns_of l)
    using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed (g ---> g')
Γ ⊢i foldr patt_imp g' (patterns_of l) using i
  apply well_formed_imp_proj1 in wfimp.
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp g (patterns_of l)
    using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
Γ ⊢i foldr patt_imp g' (patterns_of l) using i
  eapply prf_weaken_conclusion_iter_meta_meta.
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp g (patterns_of l)
    using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp g (patterns_of l)
    using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
well_formed ?g
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp g (patterns_of l)
    using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
well_formed g'
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp g (patterns_of l)
    using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
Γ ⊢i ?g ---> g' using i
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp g (patterns_of l)
    using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
Γ ⊢i foldr patt_imp ?g (patterns_of l) using i
  5: apply Hlg.
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp g (patterns_of l)
    using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp g (patterns_of l)
    using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
well_formed g
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp g (patterns_of l)
    using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
well_formed g'
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp g (patterns_of l)
    using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
Γ ⊢i g ---> g' using i
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp g (patterns_of l)
    using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
well_formed g
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp g (patterns_of l)
    using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
Pattern.wf (patterns_of l)
  4: apply Hgg'.
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp g (patterns_of l)
    using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp g (patterns_of l)
    using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
well_formed g
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp g (patterns_of l)
    using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
well_formed g'
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp g (patterns_of l)
    using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
well_formed g
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp g (patterns_of l)
    using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
Pattern.wf (patterns_of l)
  all: assumption.
Defined.

Lemma prf_contraction {Σ : Signature} Γ a b:
  well_formed a ->
  well_formed b ->
  Γ ⊢i ((a ---> a ---> b) ---> (a ---> b)) using BasicReasoning.
Σ: Signature
Γ: Theory
a, b: Pattern
well_formed a
→ well_formed b
  → Γ ⊢i (a ---> a ---> b) ---> a ---> b
    using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
a, b: Pattern
well_formed a
→ well_formed b
  → Γ ⊢i (a ---> a ---> b) ---> a ---> b
    using BasicReasoning
  intros wfa wfb.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ ⊢i (a ---> a ---> b) ---> a ---> b
using BasicReasoning
  assert (H1 : Γ ⊢i (a ---> ((a ---> b) ---> b)) using BasicReasoning).
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ ⊢i a ---> (a ---> b) ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
H1: Γ ⊢i a ---> (a ---> b) ---> b
using BasicReasoning
Γ ⊢i (a ---> a ---> b) ---> a ---> b
using BasicReasoning
  {
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ ⊢i a ---> (a ---> b) ---> b using BasicReasoning
    apply modus_ponens; assumption.
  }
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
H1: Γ ⊢i a ---> (a ---> b) ---> b
using BasicReasoning
Γ ⊢i (a ---> a ---> b) ---> a ---> b
using BasicReasoning
  assert (H2 : Γ ⊢i ((a ---> ((a ---> b) ---> b)) ---> ((a ---> (a ---> b)) ---> (a ---> b))) using BasicReasoning).
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
H1: Γ ⊢i a ---> (a ---> b) ---> b
using BasicReasoning
Γ
⊢i (a ---> (a ---> b) ---> b) --->
   (a ---> a ---> b) ---> a ---> b
using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
H1: Γ ⊢i a ---> (a ---> b) ---> b
using BasicReasoning
H2: Γ
⊢i (a ---> (a ---> b) ---> b) --->
   (a ---> a ---> b) ---> a ---> b
using BasicReasoning
Γ ⊢i (a ---> a ---> b) ---> a ---> b
using BasicReasoning
  {
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
H1: Γ ⊢i a ---> (a ---> b) ---> b
using BasicReasoning
Γ
⊢i (a ---> (a ---> b) ---> b) --->
   (a ---> a ---> b) ---> a ---> b
using BasicReasoning
    apply P2; wf_auto2.
  }
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
H1: Γ ⊢i a ---> (a ---> b) ---> b
using BasicReasoning
H2: Γ
⊢i (a ---> (a ---> b) ---> b) --->
   (a ---> a ---> b) ---> a ---> b
using BasicReasoning
Γ ⊢i (a ---> a ---> b) ---> a ---> b
using BasicReasoning
  eapply MP.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
H1: Γ ⊢i a ---> (a ---> b) ---> b
using BasicReasoning
H2: Γ
⊢i (a ---> (a ---> b) ---> b) --->
   (a ---> a ---> b) ---> a ---> b
using BasicReasoning
Γ ⊢i ?ϕ₁ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
H1: Γ ⊢i a ---> (a ---> b) ---> b
using BasicReasoning
H2: Γ
⊢i (a ---> (a ---> b) ---> b) --->
   (a ---> a ---> b) ---> a ---> b
using BasicReasoning
Γ ⊢i ?ϕ₁ ---> (a ---> a ---> b) ---> a ---> b
using BasicReasoning 2: apply H2.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
H1: Γ ⊢i a ---> (a ---> b) ---> b
using BasicReasoning
H2: Γ
⊢i (a ---> (a ---> b) ---> b) --->
   (a ---> a ---> b) ---> a ---> b
using BasicReasoning
Γ ⊢i a ---> (a ---> b) ---> b using BasicReasoning apply H1.
Defined.

Lemma prf_weaken_conclusion_under_implication {Σ : Signature} Γ a b c:
  well_formed a ->
  well_formed b ->
  well_formed c ->
  Γ ⊢i ((a ---> b) ---> ((a ---> (b ---> c)) ---> (a ---> c))) using BasicReasoning.
Σ: Signature
Γ: Theory
a, b, c: Pattern
well_formed a
→ well_formed b
  → well_formed c
    → Γ
      ⊢i (a ---> b) --->
         (a ---> b ---> c) ---> a ---> c
      using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
a, b, c: Pattern
well_formed a
→ well_formed b
  → well_formed c
    → Γ
      ⊢i (a ---> b) --->
         (a ---> b ---> c) ---> a ---> c
      using BasicReasoning
  intros wfa wfb wfc.
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ ⊢i (a ---> b) ---> (a ---> b ---> c) ---> a ---> c
using BasicReasoning
  assert (H1 : Γ ⊢i ((a ---> (b ---> c)) ---> (b ---> (a ---> c))) using BasicReasoning).
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c
using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c
using BasicReasoning
Γ ⊢i (a ---> b) ---> (a ---> b ---> c) ---> a ---> c
using BasicReasoning
  {
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c
using BasicReasoning
    apply reorder; wf_auto2.
  }
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c
using BasicReasoning
Γ ⊢i (a ---> b) ---> (a ---> b ---> c) ---> a ---> c
using BasicReasoning
  assert (H2 : Γ ⊢i (((b ---> (a ---> c)) ---> (a ---> c)) ---> ((a ---> (b ---> c)) ---> (a ---> c))) using BasicReasoning).
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c
using BasicReasoning
Γ
⊢i ((b ---> a ---> c) ---> a ---> c) --->
   (a ---> b ---> c) ---> a ---> c
using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c
using BasicReasoning
H2: Γ
⊢i ((b ---> a ---> c) ---> a ---> c) --->
   (a ---> b ---> c) ---> a ---> c
using BasicReasoning
Γ ⊢i (a ---> b) ---> (a ---> b ---> c) ---> a ---> c
using BasicReasoning
  {
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c
using BasicReasoning
Γ
⊢i ((b ---> a ---> c) ---> a ---> c) --->
   (a ---> b ---> c) ---> a ---> c
using BasicReasoning
    apply prf_strenghten_premise_meta;[wf_auto2|wf_auto2|wf_auto2|].
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c
using BasicReasoning
Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c
using BasicReasoning
    apply H1.
  }
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c
using BasicReasoning
H2: Γ
⊢i ((b ---> a ---> c) ---> a ---> c) --->
   (a ---> b ---> c) ---> a ---> c
using BasicReasoning
Γ ⊢i (a ---> b) ---> (a ---> b ---> c) ---> a ---> c
using BasicReasoning
  eapply prf_weaken_conclusion_meta_meta.
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c
using BasicReasoning
H2: Γ
⊢i ((b ---> a ---> c) ---> a ---> c) --->
   (a ---> b ---> c) ---> a ---> c
using BasicReasoning
well_formed (a ---> b)
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c
using BasicReasoning
H2: Γ
⊢i ((b ---> a ---> c) ---> a ---> c) --->
   (a ---> b ---> c) ---> a ---> c
using BasicReasoning
well_formed ?B
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c
using BasicReasoning
H2: Γ
⊢i ((b ---> a ---> c) ---> a ---> c) --->
   (a ---> b ---> c) ---> a ---> c
using BasicReasoning
well_formed ((a ---> b ---> c) ---> a ---> c)
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c
using BasicReasoning
H2: Γ
⊢i ((b ---> a ---> c) ---> a ---> c) --->
   (a ---> b ---> c) ---> a ---> c
using BasicReasoning
Γ ⊢i ?B ---> (a ---> b ---> c) ---> a ---> c
using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c
using BasicReasoning
H2: Γ
⊢i ((b ---> a ---> c) ---> a ---> c) --->
   (a ---> b ---> c) ---> a ---> c
using BasicReasoning
Γ ⊢i (a ---> b) ---> ?B using BasicReasoning
  4: apply H2.
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c
using BasicReasoning
H2: Γ
⊢i ((b ---> a ---> c) ---> a ---> c) --->
   (a ---> b ---> c) ---> a ---> c
using BasicReasoning
well_formed (a ---> b)
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c
using BasicReasoning
H2: Γ
⊢i ((b ---> a ---> c) ---> a ---> c) --->
   (a ---> b ---> c) ---> a ---> c
using BasicReasoning
well_formed ((b ---> a ---> c) ---> a ---> c)
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c
using BasicReasoning
H2: Γ
⊢i ((b ---> a ---> c) ---> a ---> c) --->
   (a ---> b ---> c) ---> a ---> c
using BasicReasoning
well_formed ((a ---> b ---> c) ---> a ---> c)
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c
using BasicReasoning
H2: Γ
⊢i ((b ---> a ---> c) ---> a ---> c) --->
   (a ---> b ---> c) ---> a ---> c
using BasicReasoning
Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> c
using BasicReasoning 1-3: wf_auto2.
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c
using BasicReasoning
H2: Γ
⊢i ((b ---> a ---> c) ---> a ---> c) --->
   (a ---> b ---> c) ---> a ---> c
using BasicReasoning
Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> c
using BasicReasoning clear H1 H2.
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> c
using BasicReasoning

  assert (H3 : Γ ⊢i ((a ---> b) ---> ((b ---> (a ---> c)) ---> (a ---> (a ---> c)))) using BasicReasoning).
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ
⊢i (a ---> b) --->
   (b ---> a ---> c) ---> a ---> a ---> c
using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ
⊢i (a ---> b) --->
   (b ---> a ---> c) ---> a ---> a ---> c
using BasicReasoning
Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> c
using BasicReasoning
  {
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ
⊢i (a ---> b) --->
   (b ---> a ---> c) ---> a ---> a ---> c
using BasicReasoning
    apply syllogism; wf_auto2.
  }
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ
⊢i (a ---> b) --->
   (b ---> a ---> c) ---> a ---> a ---> c
using BasicReasoning
Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> c
using BasicReasoning
  assert (H4 : Γ ⊢i ((a ---> (a ---> c)) ---> (a ---> c)) using BasicReasoning).
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ
⊢i (a ---> b) --->
   (b ---> a ---> c) ---> a ---> a ---> c
using BasicReasoning
Γ ⊢i (a ---> a ---> c) ---> a ---> c
using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ
⊢i (a ---> b) --->
   (b ---> a ---> c) ---> a ---> a ---> c
using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c
using BasicReasoning
Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> c
using BasicReasoning
  {
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ
⊢i (a ---> b) --->
   (b ---> a ---> c) ---> a ---> a ---> c
using BasicReasoning
Γ ⊢i (a ---> a ---> c) ---> a ---> c
using BasicReasoning
    apply prf_contraction; wf_auto2.
  }
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ
⊢i (a ---> b) --->
   (b ---> a ---> c) ---> a ---> a ---> c
using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c
using BasicReasoning
Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> c
using BasicReasoning
  assert (Hiter: ((a ---> b) ---> (b ---> a ---> c) ---> a ---> c)
                 = foldr patt_imp (a ---> c) [(a ---> b); (b ---> a ---> c)]) by reflexivity.
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ
⊢i (a ---> b) --->
   (b ---> a ---> c) ---> a ---> a ---> c
using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c
using BasicReasoning
Hiter: ((a ---> b) --->
 (b ---> a ---> c) ---> a ---> c) =
foldr patt_imp (a ---> c)
  [a ---> b; b ---> a ---> c]
Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> c
using BasicReasoning

  eapply (cast_proof' _ _ _ _ Hiter).
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ
⊢i (a ---> b) --->
   (b ---> a ---> c) ---> a ---> a ---> c
using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c
using BasicReasoning
Hiter: ((a ---> b) --->
 (b ---> a ---> c) ---> a ---> c) =
foldr patt_imp (a ---> c)
  [a ---> b; b ---> a ---> c]
Γ
⊢i foldr patt_imp (a ---> c)
     [a ---> b; b ---> a ---> c] using BasicReasoning

  eapply prf_weaken_conclusion_iter_meta_meta.
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ
⊢i (a ---> b) --->
   (b ---> a ---> c) ---> a ---> a ---> c
using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c
using BasicReasoning
Hiter: ((a ---> b) --->
 (b ---> a ---> c) ---> a ---> c) =
foldr patt_imp (a ---> c)
  [a ---> b; b ---> a ---> c]
Pattern.wf [a ---> b; b ---> a ---> c]
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ
⊢i (a ---> b) --->
   (b ---> a ---> c) ---> a ---> a ---> c
using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c
using BasicReasoning
Hiter: ((a ---> b) --->
 (b ---> a ---> c) ---> a ---> c) =
foldr patt_imp (a ---> c)
  [a ---> b; b ---> a ---> c]
well_formed ?g
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ
⊢i (a ---> b) --->
   (b ---> a ---> c) ---> a ---> a ---> c
using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c
using BasicReasoning
Hiter: ((a ---> b) --->
 (b ---> a ---> c) ---> a ---> c) =
foldr patt_imp (a ---> c)
  [a ---> b; b ---> a ---> c]
well_formed (a ---> c)
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ
⊢i (a ---> b) --->
   (b ---> a ---> c) ---> a ---> a ---> c
using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c
using BasicReasoning
Hiter: ((a ---> b) --->
 (b ---> a ---> c) ---> a ---> c) =
foldr patt_imp (a ---> c)
  [a ---> b; b ---> a ---> c]
Γ ⊢i ?g ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ
⊢i (a ---> b) --->
   (b ---> a ---> c) ---> a ---> a ---> c
using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c
using BasicReasoning
Hiter: ((a ---> b) --->
 (b ---> a ---> c) ---> a ---> c) =
foldr patt_imp (a ---> c)
  [a ---> b; b ---> a ---> c]
Γ ⊢i foldr patt_imp ?g [a ---> b; b ---> a ---> c]
using BasicReasoning
  5: apply H3.
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ
⊢i (a ---> b) --->
   (b ---> a ---> c) ---> a ---> a ---> c
using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c
using BasicReasoning
Hiter: ((a ---> b) --->
 (b ---> a ---> c) ---> a ---> c) =
foldr patt_imp (a ---> c)
  [a ---> b; b ---> a ---> c]
Pattern.wf [a ---> b; b ---> a ---> c]
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ
⊢i (a ---> b) --->
   (b ---> a ---> c) ---> a ---> a ---> c
using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c
using BasicReasoning
Hiter: ((a ---> b) --->
 (b ---> a ---> c) ---> a ---> c) =
foldr patt_imp (a ---> c)
  [a ---> b; b ---> a ---> c]
well_formed (a ---> a ---> c)
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ
⊢i (a ---> b) --->
   (b ---> a ---> c) ---> a ---> a ---> c
using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c
using BasicReasoning
Hiter: ((a ---> b) --->
 (b ---> a ---> c) ---> a ---> c) =
foldr patt_imp (a ---> c)
  [a ---> b; b ---> a ---> c]
well_formed (a ---> c)
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ
⊢i (a ---> b) --->
   (b ---> a ---> c) ---> a ---> a ---> c
using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c
using BasicReasoning
Hiter: ((a ---> b) --->
 (b ---> a ---> c) ---> a ---> c) =
foldr patt_imp (a ---> c)
  [a ---> b; b ---> a ---> c]
Γ ⊢i (a ---> a ---> c) ---> a ---> c
using BasicReasoning 4: apply H4.
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ
⊢i (a ---> b) --->
   (b ---> a ---> c) ---> a ---> a ---> c
using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c
using BasicReasoning
Hiter: ((a ---> b) --->
 (b ---> a ---> c) ---> a ---> c) =
foldr patt_imp (a ---> c)
  [a ---> b; b ---> a ---> c]
Pattern.wf [a ---> b; b ---> a ---> c]
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ
⊢i (a ---> b) --->
   (b ---> a ---> c) ---> a ---> a ---> c
using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c
using BasicReasoning
Hiter: ((a ---> b) --->
 (b ---> a ---> c) ---> a ---> c) =
foldr patt_imp (a ---> c)
  [a ---> b; b ---> a ---> c]
well_formed (a ---> a ---> c)
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ
⊢i (a ---> b) --->
   (b ---> a ---> c) ---> a ---> a ---> c
using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c
using BasicReasoning
Hiter: ((a ---> b) --->
 (b ---> a ---> c) ---> a ---> c) =
foldr patt_imp (a ---> c)
  [a ---> b; b ---> a ---> c]
well_formed (a ---> c) all: wf_auto2.
Defined.

Lemma prf_weaken_conclusion_under_implication_meta {Σ : Signature} Γ a b c (i : ProofInfo):
  well_formed a ->
  well_formed b ->
  well_formed c ->
  Γ ⊢i (a ---> b) using i ->
  Γ ⊢i ((a ---> (b ---> c)) ---> (a ---> c)) using i.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
well_formed a
→ well_formed b
  → well_formed c
    → Γ ⊢i a ---> b using i
      → Γ ⊢i (a ---> b ---> c) ---> a ---> c using i
Proof.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
well_formed a
→ well_formed b
  → well_formed c
    → Γ ⊢i a ---> b using i
      → Γ ⊢i (a ---> b ---> c) ---> a ---> c using i
  intros wfa wfb wfc H.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b using i
Γ ⊢i (a ---> b ---> c) ---> a ---> c using i
  eapply MP.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b using i
Γ ⊢i ?ϕ₁ ---> (a ---> b ---> c) ---> a ---> c using i
  2: {
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b using i
Γ ⊢i ?ϕ₁ ---> (a ---> b ---> c) ---> a ---> c using i useBasicReasoning.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b using i
Γ ⊢i ?ϕ₁ ---> (a ---> b ---> c) ---> a ---> c
using BasicReasoning apply prf_weaken_conclusion_under_implication; wf_auto2. }
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b using i
Γ ⊢i a ---> b using i
  exact H.
Defined.

Lemma prf_weaken_conclusion_under_implication_meta_meta {Σ : Signature} Γ a b c i:
  well_formed a ->
  well_formed b ->
  well_formed c ->
  Γ ⊢i a ---> b using i ->
  Γ ⊢i a ---> b ---> c using i ->
  Γ ⊢i a ---> c using i.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
well_formed a
→ well_formed b
  → well_formed c
    → Γ ⊢i a ---> b using i
      → Γ ⊢i a ---> b ---> c using i
        → Γ ⊢i a ---> c using i
Proof.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
well_formed a
→ well_formed b
  → well_formed c
    → Γ ⊢i a ---> b using i
      → Γ ⊢i a ---> b ---> c using i
        → Γ ⊢i a ---> c using i
  intros wfa wfb wfc H1 H2.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i
Γ ⊢i a ---> c using i
  eapply MP.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i
Γ ⊢i ?ϕ₁ ---> a ---> c using i
  {
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i
Γ ⊢i ?ϕ₁ using i apply H2. }
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i
Γ ⊢i (a ---> b ---> c) ---> a ---> c using i
  {
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i
Γ ⊢i (a ---> b ---> c) ---> a ---> c using i apply prf_weaken_conclusion_under_implication_meta.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i
well_formed a
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i
well_formed b
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i
well_formed c
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i
Γ ⊢i a ---> b using i
    4: {
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i
Γ ⊢i a ---> b using i apply H1. }
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i
well_formed a
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i
well_formed b
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i
well_formed c
    all: wf_auto2.
  }
Defined.

Lemma prf_weaken_conclusion_iter_under_implication {Σ : Signature} Γ l g g':
  Pattern.wf l ->
  well_formed g ->
  well_formed g' ->
  Γ ⊢i (((g ---> g') ---> (foldr patt_imp g l)) ---> ((g ---> g') ---> (foldr patt_imp g' l)))
  using BasicReasoning.
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
Pattern.wf l
→ well_formed g
  → well_formed g'
    → Γ
      ⊢i ((g ---> g') ---> foldr patt_imp g l) --->
         (g ---> g') ---> foldr patt_imp g' l
      using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
Pattern.wf l
→ well_formed g
  → well_formed g'
    → Γ
      ⊢i ((g ---> g') ---> foldr patt_imp g l) --->
         (g ---> g') ---> foldr patt_imp g' l
      using BasicReasoning
  intros wfl wfg wfg'.
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
Γ
⊢i ((g ---> g') ---> foldr patt_imp g l) --->
   (g ---> g') ---> foldr patt_imp g' l
using BasicReasoning
  pose proof (H1 := prf_weaken_conclusion_iter Γ l g g' wfl wfg wfg').
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
H1: Γ
⊢i (g ---> g') --->
   foldr patt_imp g l ---> foldr patt_imp g' l
using BasicReasoning
Γ
⊢i ((g ---> g') ---> foldr patt_imp g l) --->
   (g ---> g') ---> foldr patt_imp g' l
using BasicReasoning
  remember ((g ---> g')) as a.
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
H1: Γ
⊢i a --->
   foldr patt_imp g l ---> foldr patt_imp g' l
using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp g l) --->
   a ---> foldr patt_imp g' l using BasicReasoning
  remember (foldr patt_imp g l) as b.
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
H1: Γ ⊢i a ---> b ---> foldr patt_imp g' l
using BasicReasoning
Γ ⊢i (a ---> b) ---> a ---> foldr patt_imp g' l
using BasicReasoning
  remember (foldr patt_imp g' l) as c.
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
c: Pattern
Heqc: c = foldr patt_imp g' l
H1: Γ ⊢i a ---> b ---> c using BasicReasoning
Γ ⊢i (a ---> b) ---> a ---> c using BasicReasoning
  assert (well_formed a) by (subst; wf_auto2).
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
c: Pattern
Heqc: c = foldr patt_imp g' l
H1: Γ ⊢i a ---> b ---> c using BasicReasoning
H: well_formed a
Γ ⊢i (a ---> b) ---> a ---> c using BasicReasoning
  assert (well_formed b) by (subst; wf_auto2).
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
c: Pattern
Heqc: c = foldr patt_imp g' l
H1: Γ ⊢i a ---> b ---> c using BasicReasoning
H: well_formed a
H0: well_formed b
Γ ⊢i (a ---> b) ---> a ---> c using BasicReasoning
  assert (well_formed c) by (subst; wf_auto2).
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
c: Pattern
Heqc: c = foldr patt_imp g' l
H1: Γ ⊢i a ---> b ---> c using BasicReasoning
H: well_formed a
H0: well_formed b
H2: well_formed c
Γ ⊢i (a ---> b) ---> a ---> c using BasicReasoning
  pose proof (H2' := prf_weaken_conclusion_under_implication Γ a b c ltac:(assumption) ltac:(assumption) ltac:(assumption)).
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
c: Pattern
Heqc: c = foldr patt_imp g' l
H1: Γ ⊢i a ---> b ---> c using BasicReasoning
H: well_formed a
H0: well_formed b
H2: well_formed c
H2': Γ
⊢i (a ---> b) --->
   (a ---> b ---> c) ---> a ---> c
using BasicReasoning
Γ ⊢i (a ---> b) ---> a ---> c using BasicReasoning
  apply reorder_meta in H2'.
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
c: Pattern
Heqc: c = foldr patt_imp g' l
H1: Γ ⊢i a ---> b ---> c using BasicReasoning
H: well_formed a
H0: well_formed b
H2: well_formed c
H2': Γ
⊢i (a ---> b ---> c) --->
   (a ---> b) ---> a ---> c using BasicReasoning
Γ ⊢i (a ---> b) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
c: Pattern
Heqc: c = foldr patt_imp g' l
H1: Γ ⊢i a ---> b ---> c using BasicReasoning
H: well_formed a
H0: well_formed b
H2: well_formed c
H2': Γ
⊢i (a ---> b) --->
   (a ---> b ---> c) ---> a ---> c
using BasicReasoning
well_formed (a ---> b)
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
c: Pattern
Heqc: c = foldr patt_imp g' l
H1: Γ ⊢i a ---> b ---> c using BasicReasoning
H: well_formed a
H0: well_formed b
H2: well_formed c
H2': Γ
⊢i (a ---> b) --->
   (a ---> b ---> c) ---> a ---> c
using BasicReasoning
well_formed (a ---> b ---> c)
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
c: Pattern
Heqc: c = foldr patt_imp g' l
H1: Γ ⊢i a ---> b ---> c using BasicReasoning
H: well_formed a
H0: well_formed b
H2: well_formed c
H2': Γ
⊢i (a ---> b) --->
   (a ---> b ---> c) ---> a ---> c
using BasicReasoning
well_formed (a ---> c) 2,3,4: subst;wf_auto2.
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
c: Pattern
Heqc: c = foldr patt_imp g' l
H1: Γ ⊢i a ---> b ---> c using BasicReasoning
H: well_formed a
H0: well_formed b
H2: well_formed c
H2': Γ
⊢i (a ---> b ---> c) --->
   (a ---> b) ---> a ---> c using BasicReasoning
Γ ⊢i (a ---> b) ---> a ---> c using BasicReasoning
  eapply MP.
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
c: Pattern
Heqc: c = foldr patt_imp g' l
H1: Γ ⊢i a ---> b ---> c using BasicReasoning
H: well_formed a
H0: well_formed b
H2: well_formed c
H2': Γ
⊢i (a ---> b ---> c) --->
   (a ---> b) ---> a ---> c using BasicReasoning
Γ ⊢i ?ϕ₁ using BasicReasoning
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
c: Pattern
Heqc: c = foldr patt_imp g' l
H1: Γ ⊢i a ---> b ---> c using BasicReasoning
H: well_formed a
H0: well_formed b
H2: well_formed c
H2': Γ
⊢i (a ---> b ---> c) --->
   (a ---> b) ---> a ---> c using BasicReasoning
Γ ⊢i ?ϕ₁ ---> (a ---> b) ---> a ---> c
using BasicReasoning 2: apply H2'.
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
c: Pattern
Heqc: c = foldr patt_imp g' l
H1: Γ ⊢i a ---> b ---> c using BasicReasoning
H: well_formed a
H0: well_formed b
H2: well_formed c
H2': Γ
⊢i (a ---> b ---> c) --->
   (a ---> b) ---> a ---> c using BasicReasoning
Γ ⊢i a ---> b ---> c using BasicReasoning apply H1.
Defined.

Lemma prf_weaken_conclusion_iter_under_implication_meta {Σ : Signature} Γ l g g' (i : ProofInfo):
  Pattern.wf l ->
  well_formed g ->
  well_formed g' ->
  Γ ⊢i ((g ---> g') ---> (foldr patt_imp g l)) using i->
  Γ ⊢i ((g ---> g') ---> (foldr patt_imp g' l)) using i.
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
i: ProofInfo
Pattern.wf l
→ well_formed g
  → well_formed g'
    → Γ ⊢i (g ---> g') ---> foldr patt_imp g l using i
      → Γ ⊢i (g ---> g') ---> foldr patt_imp g' l
        using i
Proof.
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
i: ProofInfo
Pattern.wf l
→ well_formed g
  → well_formed g'
    → Γ ⊢i (g ---> g') ---> foldr patt_imp g l using i
      → Γ ⊢i (g ---> g') ---> foldr patt_imp g' l
        using i
  intros wfl wfg wfg' H.
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
i: ProofInfo
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i (g ---> g') ---> foldr patt_imp g l using i
Γ ⊢i (g ---> g') ---> foldr patt_imp g' l using i
  eapply MP.
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
i: ProofInfo
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i (g ---> g') ---> foldr patt_imp g l using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
i: ProofInfo
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i (g ---> g') ---> foldr patt_imp g l using i
Γ ⊢i ?ϕ₁ ---> (g ---> g') ---> foldr patt_imp g' l
using i
  2: {
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
i: ProofInfo
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i (g ---> g') ---> foldr patt_imp g l using i
Γ ⊢i ?ϕ₁ ---> (g ---> g') ---> foldr patt_imp g' l
using i useBasicReasoning.
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
i: ProofInfo
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i (g ---> g') ---> foldr patt_imp g l using i
Γ ⊢i ?ϕ₁ ---> (g ---> g') ---> foldr patt_imp g' l
using BasicReasoning apply prf_weaken_conclusion_iter_under_implication; wf_auto2. }
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
i: ProofInfo
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i (g ---> g') ---> foldr patt_imp g l using i
Γ ⊢i (g ---> g') ---> foldr patt_imp g l using i
  {
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
i: ProofInfo
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i (g ---> g') ---> foldr patt_imp g l using i
Γ ⊢i (g ---> g') ---> foldr patt_imp g l using i exact H. }
Defined.

Lemma MLGoal_weakenConclusion_under_first_implication {Σ : Signature} Γ l name g g' i:
  mkMLGoal Σ Γ (mkNH _ name (g ---> g') :: l) g i ->
  mkMLGoal Σ Γ (mkNH _ name (g ---> g') :: l) g' i .
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
Γ Ⱶ
(name ∶ g ---> g') :: l--------------------------------------
g
using i

→ Γ Ⱶ
(name ∶ g ---> g') :: l--------------------------------------
g'
using i

Proof.
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
Γ Ⱶ
(name ∶ g ---> g') :: l--------------------------------------
g
using i

→ Γ Ⱶ
(name ∶ g ---> g') :: l--------------------------------------
g'
using i

  intros H.
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: Γ Ⱶ
(name ∶ g ---> g') :: l--------------------------------------
g
using i

Γ Ⱶ
(name ∶ g ---> g') :: l--------------------------------------
g'
using i
 unfold of_MLGoal in *.
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed
  (mlConclusion
     (Γ Ⱶ
      (name ∶ g ---> g') :: l--------------------------------------
      g
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           (name ∶ g ---> g') :: l--------------------------------------
           g
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       (name ∶ g ---> g') :: l--------------------------------------
       g
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             (name ∶ g ---> g') :: l--------------------------------------
             g
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                (name ∶ g ---> g') :: l--------------------------------------
                g
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             (name ∶ g ---> g') :: l--------------------------------------
             g
             using i
             )
well_formed
  (mlConclusion
     (Γ Ⱶ
      (name ∶ g ---> g') :: l--------------------------------------
      g'
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           (name ∶ g ---> g') :: l--------------------------------------
           g'
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       (name ∶ g ---> g') :: l--------------------------------------
       g'
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             (name ∶ g ---> g') :: l--------------------------------------
             g'
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                (name ∶ g ---> g') :: l--------------------------------------
                g'
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             (name ∶ g ---> g') :: l--------------------------------------
             g'
             using i
             ) simpl in *.
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf ((g ---> g') :: patterns_of l)
  → Γ
    ⊢i (g ---> g') --->
       foldr patt_imp g (patterns_of l) using i
well_formed g'
→ Pattern.wf ((g ---> g') :: patterns_of l)
  → Γ
    ⊢i (g ---> g') --->
       foldr patt_imp g' (patterns_of l) using i
  intros wfg' wfgg'l.
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf ((g ---> g') :: patterns_of l)
  → Γ
    ⊢i (g ---> g') --->
       foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfgg'l: Pattern.wf ((g ---> g') :: patterns_of l)
Γ
⊢i (g ---> g') ---> foldr patt_imp g' (patterns_of l)
using i
  pose proof (Htmp := wfgg'l).
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf ((g ---> g') :: patterns_of l)
  → Γ
    ⊢i (g ---> g') --->
       foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfgg'l, Htmp: Pattern.wf ((g ---> g') :: patterns_of l)
Γ
⊢i (g ---> g') ---> foldr patt_imp g' (patterns_of l)
using i
  unfold Pattern.wf in Htmp.
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf ((g ---> g') :: patterns_of l)
  → Γ
    ⊢i (g ---> g') --->
       foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfgg'l: Pattern.wf ((g ---> g') :: patterns_of l)
Htmp: foldr andb true
  (map well_formed
     ((g ---> g') :: patterns_of l))
Γ
⊢i (g ---> g') ---> foldr patt_imp g' (patterns_of l)
using i simpl in Htmp.
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf ((g ---> g') :: patterns_of l)
  → Γ
    ⊢i (g ---> g') --->
       foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfgg'l: Pattern.wf ((g ---> g') :: patterns_of l)
Htmp: well_formed (g ---> g') &&
foldr andb true
  (map well_formed (patterns_of l))
Γ
⊢i (g ---> g') ---> foldr patt_imp g' (patterns_of l)
using i apply andb_prop in Htmp.
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf ((g ---> g') :: patterns_of l)
  → Γ
    ⊢i (g ---> g') --->
       foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfgg'l: Pattern.wf ((g ---> g') :: patterns_of l)
Htmp: well_formed (g ---> g') = true
∧ foldr andb true
    (map well_formed (patterns_of l)) = true
Γ
⊢i (g ---> g') ---> foldr patt_imp g' (patterns_of l)
using i destruct Htmp as [wfgg' wfl].
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf ((g ---> g') :: patterns_of l)
  → Γ
    ⊢i (g ---> g') --->
       foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfgg'l: Pattern.wf ((g ---> g') :: patterns_of l)
wfgg': well_formed (g ---> g') = true
wfl: foldr andb true
  (map well_formed (patterns_of l)) = true
Γ
⊢i (g ---> g') ---> foldr patt_imp g' (patterns_of l)
using i
  apply well_formed_imp_proj1 in wfgg'.
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf ((g ---> g') :: patterns_of l)
  → Γ
    ⊢i (g ---> g') --->
       foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfgg'l: Pattern.wf ((g ---> g') :: patterns_of l)
wfgg': well_formed g
wfl: foldr andb true
  (map well_formed (patterns_of l)) = true
Γ
⊢i (g ---> g') ---> foldr patt_imp g' (patterns_of l)
using i specialize (H wfgg' wfgg'l).
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: Γ
⊢i (g ---> g') --->
   foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfgg'l: Pattern.wf ((g ---> g') :: patterns_of l)
wfgg': well_formed g
wfl: foldr andb true
  (map well_formed (patterns_of l)) = true
Γ
⊢i (g ---> g') ---> foldr patt_imp g' (patterns_of l)
using i
  apply prf_weaken_conclusion_iter_under_implication_meta; assumption.
Defined.

Lemma prf_weaken_conclusion_iter_under_implication_iter {Σ : Signature} Γ l₁ l₂ g g':
  Pattern.wf l₁ ->
  Pattern.wf l₂ ->
  well_formed g ->
  well_formed g' ->
  Γ ⊢i ((foldr patt_imp g (l₁ ++ (g ---> g') :: l₂)) --->
       (foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂)))
  using BasicReasoning.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
g, g': Pattern
Pattern.wf l₁
→ Pattern.wf l₂
  → well_formed g
    → well_formed g'
      → Γ
        ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) --->
           foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂)
        using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
g, g': Pattern
Pattern.wf l₁
→ Pattern.wf l₂
  → well_formed g
    → well_formed g'
      → Γ
        ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) --->
           foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂)
        using BasicReasoning
  intros wfl₁ wfl₂ wfg wfg'.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
g, g': Pattern
wfl₁: Pattern.wf l₁
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
Γ
⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) --->
   foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂)
using BasicReasoning
  induction l₁; simpl.
Σ: Signature
Γ: Theory
l₂: list Pattern
g, g': Pattern
wfl₁: Pattern.wf []
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
Γ
⊢i ((g ---> g') ---> foldr patt_imp g l₂) --->
   (g ---> g') ---> foldr patt_imp g' l₂
using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfl₁: Pattern.wf (a :: l₁)
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Pattern.wf l₁
→ Γ
  ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) --->
     foldr patt_imp g'
       (l₁ ++ (g ---> g') :: l₂)
  using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp g (l₁ ++ (g ---> g') :: l₂)) --->
   a ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂)
using BasicReasoning
  -
Σ: Signature
Γ: Theory
l₂: list Pattern
g, g': Pattern
wfl₁: Pattern.wf []
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
Γ
⊢i ((g ---> g') ---> foldr patt_imp g l₂) --->
   (g ---> g') ---> foldr patt_imp g' l₂
using BasicReasoning apply prf_weaken_conclusion_iter_under_implication; auto.
  -
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfl₁: Pattern.wf (a :: l₁)
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Pattern.wf l₁
→ Γ
  ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) --->
     foldr patt_imp g'
       (l₁ ++ (g ---> g') :: l₂)
  using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp g (l₁ ++ (g ---> g') :: l₂)) --->
   a ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂)
using BasicReasoning pose proof (wfal₁ := wfl₁).
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfl₁: Pattern.wf (a :: l₁)
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Pattern.wf l₁
→ Γ
  ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) --->
     foldr patt_imp g'
       (l₁ ++ (g ---> g') :: l₂)
  using BasicReasoning
wfal₁: Pattern.wf (a :: l₁)
Γ
⊢i (a ---> foldr patt_imp g (l₁ ++ (g ---> g') :: l₂)) --->
   a ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂)
using BasicReasoning unfold Pattern.wf in wfl₁.
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfl₁: foldr andb true (map well_formed (a :: l₁))
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Pattern.wf l₁
→ Γ
  ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) --->
     foldr patt_imp g'
       (l₁ ++ (g ---> g') :: l₂)
  using BasicReasoning
wfal₁: Pattern.wf (a :: l₁)
Γ
⊢i (a ---> foldr patt_imp g (l₁ ++ (g ---> g') :: l₂)) --->
   a ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂)
using BasicReasoning simpl in wfl₁.
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfl₁: well_formed a &&
foldr andb true (map well_formed l₁)
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Pattern.wf l₁
→ Γ
  ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) --->
     foldr patt_imp g'
       (l₁ ++ (g ---> g') :: l₂)
  using BasicReasoning
wfal₁: Pattern.wf (a :: l₁)
Γ
⊢i (a ---> foldr patt_imp g (l₁ ++ (g ---> g') :: l₂)) --->
   a ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂)
using BasicReasoning apply andb_prop in wfl₁.
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfl₁: well_formed a = true
∧ foldr andb true (map well_formed l₁) = true
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Pattern.wf l₁
→ Γ
  ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) --->
     foldr patt_imp g'
       (l₁ ++ (g ---> g') :: l₂)
  using BasicReasoning
wfal₁: Pattern.wf (a :: l₁)
Γ
⊢i (a ---> foldr patt_imp g (l₁ ++ (g ---> g') :: l₂)) --->
   a ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂)
using BasicReasoning
    destruct wfl₁ as [wfa wfl₁].
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfa: well_formed a = true
wfl₁: foldr andb true (map well_formed l₁) = true
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Pattern.wf l₁
→ Γ
  ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) --->
     foldr patt_imp g'
       (l₁ ++ (g ---> g') :: l₂)
  using BasicReasoning
wfal₁: Pattern.wf (a :: l₁)
Γ
⊢i (a ---> foldr patt_imp g (l₁ ++ (g ---> g') :: l₂)) --->
   a ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂)
using BasicReasoning specialize (IHl₁ wfl₁).
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfa: well_formed a = true
wfl₁: foldr andb true (map well_formed l₁) = true
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Γ
⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) --->
   foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂)
using BasicReasoning
wfal₁: Pattern.wf (a :: l₁)
Γ
⊢i (a ---> foldr patt_imp g (l₁ ++ (g ---> g') :: l₂)) --->
   a ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂)
using BasicReasoning
    eapply prf_weaken_conclusion_meta.
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfa: well_formed a = true
wfl₁: foldr andb true (map well_formed l₁) = true
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Γ
⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) --->
   foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂)
using BasicReasoning
wfal₁: Pattern.wf (a :: l₁)
well_formed a
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfa: well_formed a = true
wfl₁: foldr andb true (map well_formed l₁) = true
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Γ
⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) --->
   foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂)
using BasicReasoning
wfal₁: Pattern.wf (a :: l₁)
well_formed
  (foldr patt_imp g (l₁ ++ (g ---> g') :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfa: well_formed a = true
wfl₁: foldr andb true (map well_formed l₁) = true
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Γ
⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) --->
   foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂)
using BasicReasoning
wfal₁: Pattern.wf (a :: l₁)
well_formed
  (foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfa: well_formed a = true
wfl₁: foldr andb true (map well_formed l₁) = true
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Γ
⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) --->
   foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂)
using BasicReasoning
wfal₁: Pattern.wf (a :: l₁)
Γ
⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) --->
   foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂)
using BasicReasoning 4: assumption.
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfa: well_formed a = true
wfl₁: foldr andb true (map well_formed l₁) = true
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Γ
⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) --->
   foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂)
using BasicReasoning
wfal₁: Pattern.wf (a :: l₁)
well_formed a
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfa: well_formed a = true
wfl₁: foldr andb true (map well_formed l₁) = true
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Γ
⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) --->
   foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂)
using BasicReasoning
wfal₁: Pattern.wf (a :: l₁)
well_formed
  (foldr patt_imp g (l₁ ++ (g ---> g') :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfa: well_formed a = true
wfl₁: foldr andb true (map well_formed l₁) = true
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Γ
⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) --->
   foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂)
using BasicReasoning
wfal₁: Pattern.wf (a :: l₁)
well_formed
  (foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂)) all: wf_auto2.
Defined.

Lemma prf_weaken_conclusion_iter_under_implication_iter_meta {Σ : Signature} Γ l₁ l₂ g g' i:
  Pattern.wf l₁ ->
  Pattern.wf l₂ ->
  well_formed g ->
  well_formed g' ->
  Γ ⊢i (foldr patt_imp g (l₁ ++ (g ---> g') :: l₂)) using i ->
  Γ ⊢i (foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂)) using i.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
g, g': Pattern
i: ProofInfo
Pattern.wf l₁
→ Pattern.wf l₂
  → well_formed g
    → well_formed g'
      → Γ
        ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂)
        using i
        → Γ
          ⊢i foldr patt_imp g'
               (l₁ ++ (g ---> g') :: l₂) using i
Proof.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
g, g': Pattern
i: ProofInfo
Pattern.wf l₁
→ Pattern.wf l₂
  → well_formed g
    → well_formed g'
      → Γ
        ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂)
        using i
        → Γ
          ⊢i foldr patt_imp g'
               (l₁ ++ (g ---> g') :: l₂) using i
  intros wfl₁ wfl₂ wfg wfg' H.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
g, g': Pattern
i: ProofInfo
wfl₁: Pattern.wf l₁
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂)
using i
Γ ⊢i foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂)
using i
  eapply MP.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
g, g': Pattern
i: ProofInfo
wfl₁: Pattern.wf l₁
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂)
using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
g, g': Pattern
i: ProofInfo
wfl₁: Pattern.wf l₁
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂)
using i
Γ
⊢i ?ϕ₁ --->
   foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using i
  {
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
g, g': Pattern
i: ProofInfo
wfl₁: Pattern.wf l₁
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂)
using i
Γ ⊢i ?ϕ₁ using i apply H. }
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
g, g': Pattern
i: ProofInfo
wfl₁: Pattern.wf l₁
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂)
using i
Γ
⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) --->
   foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using i
  {
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
g, g': Pattern
i: ProofInfo
wfl₁: Pattern.wf l₁
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂)
using i
Γ
⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) --->
   foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using i useBasicReasoning.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
g, g': Pattern
i: ProofInfo
wfl₁: Pattern.wf l₁
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂)
using i
Γ
⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) --->
   foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂)
using BasicReasoning apply prf_weaken_conclusion_iter_under_implication_iter; wf_auto2. }
Defined.

Lemma MLGoal_weakenConclusion {Σ : Signature} Γ l₁ l₂ name g g' i:
  mkMLGoal Σ Γ (l₁ ++ (mkNH _ name (g ---> g')) :: l₂) g i ->
  mkMLGoal Σ Γ (l₁ ++ (mkNH _ name (g ---> g')) :: l₂) g' i.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
Γ Ⱶ
l₁ ++ (name ∶ g ---> g') :: l₂--------------------------------------
g
using i

→ Γ Ⱶ
l₁ ++ (name ∶ g ---> g') :: l₂--------------------------------------
g'
using i

Proof.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
Γ Ⱶ
l₁ ++ (name ∶ g ---> g') :: l₂--------------------------------------
g
using i

→ Γ Ⱶ
l₁ ++ (name ∶ g ---> g') :: l₂--------------------------------------
g'
using i

  unfold of_MLGoal in *.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
(well_formed
   (mlConclusion
      (Γ Ⱶ
       l₁ ++ (name ∶ g ---> g') :: l₂--------------------------------------
       g
       using i
       ))
 → Pattern.wf
     (patterns_of
        (mlHypotheses
           (Γ Ⱶ
            l₁ ++ (name ∶ g ---> g') :: l₂--------------------------------------
            g
            using i
            )))
   → mlTheory
       (Γ Ⱶ
        l₁ ++ (name ∶ g ---> g') :: l₂--------------------------------------
        g
        using i
        )
     ⊢i foldr patt_imp
          (mlConclusion
             (Γ Ⱶ
              l₁ ++ (name ∶ g ---> g') :: l₂--------------------------------------
              g
              using i
              ))
          (patterns_of
             (mlHypotheses
                (Γ Ⱶ
                 l₁ ++ (name ∶ g ---> g') :: l₂--------------------------------------
                 g
                 using i
                 )))
     using mlInfo
             (Γ Ⱶ
              l₁ ++ (name ∶ g ---> g') :: l₂--------------------------------------
              g
              using i
              ))
→ well_formed
    (mlConclusion
       (Γ Ⱶ
        l₁ ++ (name ∶ g ---> g') :: l₂--------------------------------------
        g'
        using i
        ))
  → Pattern.wf
      (patterns_of
         (mlHypotheses
            (Γ Ⱶ
             l₁ ++ (name ∶ g ---> g') :: l₂--------------------------------------
             g'
             using i
             )))
    → mlTheory
        (Γ Ⱶ
         l₁ ++ (name ∶ g ---> g') :: l₂--------------------------------------
         g'
         using i
         )
      ⊢i foldr patt_imp
           (mlConclusion
              (Γ Ⱶ
               l₁ ++ (name ∶ g ---> g') :: l₂--------------------------------------
               g'
               using i
               ))
           (patterns_of
              (mlHypotheses
                 (Γ Ⱶ
                  l₁ ++ (name ∶ g ---> g') :: l₂--------------------------------------
                  g'
                  using i
                  )))
      using mlInfo
              (Γ Ⱶ
               l₁ ++ (name ∶ g ---> g') :: l₂--------------------------------------
               g'
               using i
               ) simpl in *.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
(well_formed g
 → Pattern.wf
     (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
   → Γ
     ⊢i foldr patt_imp g
          (patterns_of
             (l₁ ++ (name ∶ g ---> g') :: l₂)) using i)
→ well_formed g'
  → Pattern.wf
      (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
    → Γ
      ⊢i foldr patt_imp g'
           (patterns_of
              (l₁ ++ (name ∶ g ---> g') :: l₂))
      using i
  intros H wfg' wfl₁gg'l₂.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf
    (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of
            (l₁ ++ (name ∶ g ---> g') :: l₂))
    using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (patterns_of
     (l₁ ++ (name ∶ g ---> g') :: l₂))
Γ
⊢i foldr patt_imp g'
     (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
using i

  unfold patterns_of in wfl₁gg'l₂.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf
    (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of
            (l₁ ++ (name ∶ g ---> g') :: l₂))
    using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt
     (l₁ ++ (name ∶ g ---> g') :: l₂))
Γ
⊢i foldr patt_imp g'
     (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
using i
  rewrite map_app in wfl₁gg'l₂.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf
    (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of
            (l₁ ++ (name ∶ g ---> g') :: l₂))
    using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
Γ
⊢i foldr patt_imp g'
     (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
using i

  unfold patterns_of.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf
    (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of
            (l₁ ++ (name ∶ g ---> g') :: l₂))
    using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
Γ
⊢i foldr patt_imp g'
     (map nh_patt (l₁ ++ (name ∶ g ---> g') :: l₂))
using i
  rewrite map_app.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf
    (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of
            (l₁ ++ (name ∶ g ---> g') :: l₂))
    using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
Γ
⊢i foldr patt_imp g'
     (map nh_patt l₁ ++
      map nh_patt ((name ∶ g ---> g') :: l₂)) using i

  apply prf_weaken_conclusion_iter_under_implication_iter_meta.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf
    (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of
            (l₁ ++ (name ∶ g ---> g') :: l₂))
    using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
Pattern.wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf
    (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of
            (l₁ ++ (name ∶ g ---> g') :: l₂))
    using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l₂)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf
    (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of
            (l₁ ++ (name ∶ g ---> g') :: l₂))
    using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
well_formed g
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf
    (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of
            (l₁ ++ (name ∶ g ---> g') :: l₂))
    using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
well_formed g'
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf
    (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of
            (l₁ ++ (name ∶ g ---> g') :: l₂))
    using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
Γ
⊢i foldr patt_imp g
     (map nh_patt l₁ ++
      (g ---> g')
      :: (fix map (l : list named_hypothesis) :
              list Pattern :=
            match l with
            | [] => []
            | a :: t => nh_patt a :: map t
            end) l₂) using i
  {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf
    (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of
            (l₁ ++ (name ∶ g ---> g') :: l₂))
    using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
Pattern.wf (map nh_patt l₁) abstract (pose proof (wfl₁ := wf_take (length (patterns_of l₁)) _ wfl₁gg'l₂); simpl in wfl₁; rewrite take_app in wfl₁; exact wfl₁). }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf
    (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of
            (l₁ ++ (name ∶ g ---> g') :: l₂))
    using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l₂)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf
    (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of
            (l₁ ++ (name ∶ g ---> g') :: l₂))
    using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
well_formed g
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf
    (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of
            (l₁ ++ (name ∶ g ---> g') :: l₂))
    using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
well_formed g'
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf
    (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of
            (l₁ ++ (name ∶ g ---> g') :: l₂))
    using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
Γ
⊢i foldr patt_imp g
     (map nh_patt l₁ ++
      (g ---> g')
      :: (fix map (l : list named_hypothesis) :
              list Pattern :=
            match l with
            | [] => []
            | a :: t => nh_patt a :: map t
            end) l₂) using i
  {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf
    (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of
            (l₁ ++ (name ∶ g ---> g') :: l₂))
    using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l₂) abstract (
      pose proof (wfgg'l₂ := wf_drop (length (patterns_of l₁)) _ wfl₁gg'l₂);
      rewrite drop_app in wfgg'l₂;
      pose proof (Htmp := wfgg'l₂);
      unfold Pattern.wf in Htmp;
      simpl in Htmp;
      apply andb_prop in Htmp;
      destruct Htmp as [wfgg' wfl₂];
      exact wfl₂
    ).
  }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf
    (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of
            (l₁ ++ (name ∶ g ---> g') :: l₂))
    using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
well_formed g
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf
    (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of
            (l₁ ++ (name ∶ g ---> g') :: l₂))
    using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
well_formed g'
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf
    (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of
            (l₁ ++ (name ∶ g ---> g') :: l₂))
    using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
Γ
⊢i foldr patt_imp g
     (map nh_patt l₁ ++
      (g ---> g')
      :: (fix map (l : list named_hypothesis) :
              list Pattern :=
            match l with
            | [] => []
            | a :: t => nh_patt a :: map t
            end) l₂) using i
  {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf
    (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of
            (l₁ ++ (name ∶ g ---> g') :: l₂))
    using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
well_formed g
    abstract(
      pose proof (wfgg'l₂ := wf_drop (length (patterns_of l₁)) _ wfl₁gg'l₂);
      rewrite drop_app in wfgg'l₂;
      pose proof (Htmp := wfgg'l₂);
      unfold Pattern.wf in Htmp;
      simpl in Htmp;
      apply andb_prop in Htmp;
      destruct Htmp as [wfgg' wfl₂];
      pose proof (wfg := well_formed_imp_proj1 _ _ wfgg');
      exact wfg
    ).
  }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf
    (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of
            (l₁ ++ (name ∶ g ---> g') :: l₂))
    using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
well_formed g'
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf
    (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of
            (l₁ ++ (name ∶ g ---> g') :: l₂))
    using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
Γ
⊢i foldr patt_imp g
     (map nh_patt l₁ ++
      (g ---> g')
      :: (fix map (l : list named_hypothesis) :
              list Pattern :=
            match l with
            | [] => []
            | a :: t => nh_patt a :: map t
            end) l₂) using i
  {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf
    (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of
            (l₁ ++ (name ∶ g ---> g') :: l₂))
    using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
well_formed g' exact wfg'. }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf
    (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of
            (l₁ ++ (name ∶ g ---> g') :: l₂))
    using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
Γ
⊢i foldr patt_imp g
     (map nh_patt l₁ ++
      (g ---> g')
      :: (fix map (l : list named_hypothesis) :
              list Pattern :=
            match l with
            | [] => []
            | a :: t => nh_patt a :: map t
            end) l₂) using i

  unfold patterns_of in H.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g
→ Pattern.wf
    (map nh_patt (l₁ ++ (name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (map nh_patt
            (l₁ ++ (name ∶ g ---> g') :: l₂))
    using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
Γ
⊢i foldr patt_imp g
     (map nh_patt l₁ ++
      (g ---> g')
      :: (fix map (l : list named_hypothesis) :
              list Pattern :=
            match l with
            | [] => []
            | a :: t => nh_patt a :: map t
            end) l₂) using i
  rewrite map_app in H.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
H: well_formed g
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (map nh_patt l₁ ++
          map nh_patt ((name ∶ g ---> g') :: l₂))
    using i
Γ
⊢i foldr patt_imp g
     (map nh_patt l₁ ++
      (g ---> g')
      :: (fix map (l : list named_hypothesis) :
              list Pattern :=
            match l with
            | [] => []
            | a :: t => nh_patt a :: map t
            end) l₂) using i
  apply H.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
H: well_formed g
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (map nh_patt l₁ ++
          map nh_patt ((name ∶ g ---> g') :: l₂))
    using i
well_formed g
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
H: well_formed g
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (map nh_patt l₁ ++
          map nh_patt ((name ∶ g ---> g') :: l₂))
    using i
Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
  {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
H: well_formed g
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (map nh_patt l₁ ++
          map nh_patt ((name ∶ g ---> g') :: l₂))
    using i
well_formed g
    abstract(
      pose proof (wfgg'l₂ := wf_drop (length (patterns_of l₁)) _ wfl₁gg'l₂);
      rewrite drop_app in wfgg'l₂;
      pose proof (Htmp := wfgg'l₂);
      unfold Pattern.wf in Htmp;
      simpl in Htmp;
      apply andb_prop in Htmp;
      destruct Htmp as [wfgg' wfl₂];
      pose proof (wfg := well_formed_imp_proj1 _ _ wfgg');
      exact wfg
    ).
  }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
H: well_formed g
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((name ∶ g ---> g') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (map nh_patt l₁ ++
          map nh_patt ((name ∶ g ---> g') :: l₂))
    using i
Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((name ∶ g ---> g') :: l₂))
  exact wfl₁gg'l₂.
Defined.


Tactic Notation "mlApplyn" constr(n) :=
  _ensureProofMode;
  _mlReshapeHypsByIdx n;
  apply MLGoal_weakenConclusion;
  _mlReshapeHypsBack.


Tactic Notation "mlApply" constr(name') :=
  _ensureProofMode;
  _mlReshapeHypsByName name';
  apply MLGoal_weakenConclusion;
  _mlReshapeHypsBack.

Local Example ex_mlApplyn {Σ : Signature} Γ a b:
  well_formed a ->
  well_formed b ->
  Γ ⊢i a ---> (a ---> b) ---> b using BasicReasoning.
Σ: Signature
Γ: Theory
a, b: Pattern
well_formed a
→ well_formed b
  → Γ ⊢i a ---> (a ---> b) ---> b using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
a, b: Pattern
well_formed a
→ well_formed b
  → Γ ⊢i a ---> (a ---> b) ---> b using BasicReasoning
  intros wfa wfb.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ ⊢i a ---> (a ---> b) ---> b using BasicReasoning
  toMLGoal.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
well_formed (a ---> (a ---> b) ---> b)
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
a ---> (a ---> b) ---> b
using BasicReasoning

  {
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
well_formed (a ---> (a ---> b) ---> b) wf_auto2. }
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
a ---> (a ---> b) ---> b
using BasicReasoning

  mlIntro "H1".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H1" ∶ a,
--------------------------------------
(a ---> b) ---> b
using BasicReasoning

  mlIntro "H2".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H1" ∶ a,
"H2" ∶ a ---> b,
--------------------------------------
b
using BasicReasoning

  mlApply "H2".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H1" ∶ a,
"H2" ∶ a ---> b,
--------------------------------------
a
using BasicReasoning

  fromMLGoal.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ ⊢i a ---> (a ---> b) ---> a using BasicReasoning
  apply P1; wf_auto2.
Defined.


Lemma Constructive_dilemma {Σ : Signature} Γ p q r s:
  well_formed p ->
  well_formed q ->
  well_formed r ->
  well_formed s ->
  Γ ⊢i ((p ---> q) ---> (r ---> s) ---> (p or r) ---> (q or s)) using BasicReasoning.
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
well_formed p
→ well_formed q
  → well_formed r
    → well_formed s
      → Γ
        ⊢i (p ---> q) --->
           (r ---> s) ---> p or r ---> q or s
        using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
well_formed p
→ well_formed q
  → well_formed r
    → well_formed s
      → Γ
        ⊢i (p ---> q) --->
           (r ---> s) ---> p or r ---> q or s
        using BasicReasoning
  intros wfp wfq wfr wfs.
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s
Γ
⊢i (p ---> q) ---> (r ---> s) ---> p or r ---> q or s
using BasicReasoning
  unfold patt_or.
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s
Γ
⊢i (p ---> q) --->
   (r ---> s) ---> (! p ---> r) ---> ! q ---> s
using BasicReasoning

  toMLGoal.
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s
well_formed
  ((p ---> q) --->
   (r ---> s) ---> (! p ---> r) ---> ! q ---> s)
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s
Γ Ⱶ
(p ---> q) --->
(r ---> s) ---> (! p ---> r) ---> ! q ---> s
using BasicReasoning

  {
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s
well_formed
  ((p ---> q) --->
   (r ---> s) ---> (! p ---> r) ---> ! q ---> s) wf_auto2. }
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s
Γ Ⱶ
(p ---> q) --->
(r ---> s) ---> (! p ---> r) ---> ! q ---> s
using BasicReasoning


  mlIntro "H0".
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s
Γ Ⱶ
"H0" ∶ p ---> q,
--------------------------------------
(r ---> s) ---> (! p ---> r) ---> ! q ---> s
using BasicReasoning
 mlIntro "H1".
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s
Γ Ⱶ
"H0" ∶ p ---> q,
"H1" ∶ r ---> s,
--------------------------------------
(! p ---> r) ---> ! q ---> s
using BasicReasoning
 mlIntro "H2".
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s
Γ Ⱶ
"H0" ∶ p ---> q,
"H1" ∶ r ---> s,
"H2" ∶ ! p ---> r,
--------------------------------------
! q ---> s
using BasicReasoning
 mlIntro "H3".
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s
Γ Ⱶ
"H0" ∶ p ---> q,
"H1" ∶ r ---> s,
"H2" ∶ ! p ---> r,
"H3" ∶ ! q,
--------------------------------------
s
using BasicReasoning

  mlApply "H1".
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s
Γ Ⱶ
"H0" ∶ p ---> q,
"H1" ∶ r ---> s,
"H2" ∶ ! p ---> r,
"H3" ∶ ! q,
--------------------------------------
r
using BasicReasoning

  mlApply "H2".
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s
Γ Ⱶ
"H0" ∶ p ---> q,
"H1" ∶ r ---> s,
"H2" ∶ ! p ---> r,
"H3" ∶ ! q,
--------------------------------------
! p
using BasicReasoning

  mlIntro "H4".
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s
Γ Ⱶ
"H0" ∶ p ---> q,
"H1" ∶ r ---> s,
"H2" ∶ ! p ---> r,
"H3" ∶ ! q,
"H4" ∶ p,
--------------------------------------
⊥
using BasicReasoning

  mlApply "H3".
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s
Γ Ⱶ
"H0" ∶ p ---> q,
"H1" ∶ r ---> s,
"H2" ∶ ! p ---> r,
"H3" ∶ q ---> ⊥,
"H4" ∶ p,
--------------------------------------
q
using BasicReasoning

  mlApply "H0".
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s
Γ Ⱶ
"H0" ∶ p ---> q,
"H1" ∶ r ---> s,
"H2" ∶ ! p ---> r,
"H3" ∶ q ---> ⊥,
"H4" ∶ p,
--------------------------------------
p
using BasicReasoning

  mlExact "H4".
Defined.

Lemma prf_impl_distr_meta {Σ : Signature} Γ a b c i:
  well_formed a ->
  well_formed b ->
  well_formed c ->
  Γ ⊢i (a ---> (b ---> c)) using i ->
  Γ ⊢i ((a ---> b) ---> (a ---> c)) using i.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
well_formed a
→ well_formed b
  → well_formed c
    → Γ ⊢i a ---> b ---> c using i
      → Γ ⊢i (a ---> b) ---> a ---> c using i
Proof.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
well_formed a
→ well_formed b
  → well_formed c
    → Γ ⊢i a ---> b ---> c using i
      → Γ ⊢i (a ---> b) ---> a ---> c using i
  intros wfa wfb wfc H.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Γ ⊢i (a ---> b) ---> a ---> c using i
  eapply MP.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Γ ⊢i ?ϕ₁ ---> (a ---> b) ---> a ---> c using i
  {
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Γ ⊢i ?ϕ₁ using i apply H. }
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Γ ⊢i (a ---> b ---> c) ---> (a ---> b) ---> a ---> c
using i
  {
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Γ ⊢i (a ---> b ---> c) ---> (a ---> b) ---> a ---> c
using i useBasicReasoning.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Γ ⊢i (a ---> b ---> c) ---> (a ---> b) ---> a ---> c
using BasicReasoning apply P2; wf_auto2. }
Defined.

Lemma prf_add_lemma_under_implication {Σ : Signature} Γ l g h:
  Pattern.wf l ->
  well_formed g ->
  well_formed h ->
  Γ ⊢i ((foldr patt_imp h l) --->
       ((foldr patt_imp g (l ++ [h])) --->
        (foldr patt_imp g l)))
  using BasicReasoning.
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
Pattern.wf l
→ well_formed g
  → well_formed h
    → Γ
      ⊢i foldr patt_imp h l --->
         foldr patt_imp g (l ++ [h]) --->
         foldr patt_imp g l using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
Pattern.wf l
→ well_formed g
  → well_formed h
    → Γ
      ⊢i foldr patt_imp h l --->
         foldr patt_imp g (l ++ [h]) --->
         foldr patt_imp g l using BasicReasoning
  intros wfl wfg wfh.
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfh: well_formed h
Γ
⊢i foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l
using BasicReasoning
  induction l; simpl.
Σ: Signature
Γ: Theory
g, h: Pattern
wfl: Pattern.wf []
wfg: well_formed g
wfh: well_formed h
Γ ⊢i h ---> (h ---> g) ---> g using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfl: Pattern.wf (a :: l)
wfg: well_formed g
wfh: well_formed h
IHl: Pattern.wf l
→ Γ
⊢i foldr patt_imp h l --->
foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp h l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning
  -
Σ: Signature
Γ: Theory
g, h: Pattern
wfl: Pattern.wf []
wfg: well_formed g
wfh: well_formed h
Γ ⊢i h ---> (h ---> g) ---> g using BasicReasoning apply modus_ponens; auto.
  -
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfl: Pattern.wf (a :: l)
wfg: well_formed g
wfh: well_formed h
IHl: Pattern.wf l
→ Γ
⊢i foldr patt_imp h l --->
foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp h l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning pose proof (wfal := wfl).
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfl: Pattern.wf (a :: l)
wfg: well_formed g
wfh: well_formed h
IHl: Pattern.wf l
→ Γ
⊢i foldr patt_imp h l --->
foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i (a ---> foldr patt_imp h l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning
    unfold Pattern.wf in wfl.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfl: foldr andb true (map well_formed (a :: l))
wfg: well_formed g
wfh: well_formed h
IHl: Pattern.wf l
→ Γ
⊢i foldr patt_imp h l --->
foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i (a ---> foldr patt_imp h l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning apply andb_prop in wfl.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfl: well_formed a = true
∧ (fix fold_right (l : list bool) : bool :=
match l with
| [] => true
| b :: t => b && fold_right t
end)
((fix map (l : list Pattern) : list bool :=
match l with
| [] => []
| a :: t => well_formed a :: map t
end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Pattern.wf l
→ Γ
⊢i foldr patt_imp h l --->
foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i (a ---> foldr patt_imp h l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning destruct wfl as [wfa wfl].
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
match l with
| [] => true
| b :: t => b && fold_right t
end)
((fix map (l : list Pattern) : list bool :=
match l with
| [] => []
| a :: t => well_formed a :: map t
end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Pattern.wf l
→ Γ
⊢i foldr patt_imp h l --->
foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i (a ---> foldr patt_imp h l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning
    specialize (IHl wfl).
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
match l with
| [] => true
| b :: t => b && fold_right t
end)
((fix map (l : list Pattern) : list bool :=
match l with
| [] => []
| a :: t => well_formed a :: map t
end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ
⊢i foldr patt_imp h l --->
foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i (a ---> foldr patt_imp h l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning
    assert (H1: Γ ⊢i a --->
                    foldr patt_imp h l --->
                    foldr patt_imp g (l ++ [h]) --->
                    foldr patt_imp g l
            using BasicReasoning).
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
match l with
| [] => true
| b :: t => b && fold_right t
end)
((fix map (l : list Pattern) : list bool :=
match l with
| [] => []
| a :: t => well_formed a :: map t
end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ
⊢i foldr patt_imp h l --->
foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i a --->
   foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l
using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
   match l with
   | [] => true
   | b :: t => b && fold_right t
   end)
  ((fix map (l : list Pattern) : list bool :=
      match l with
      | [] => []
      | a :: t => well_formed a :: map t
      end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ
⊢i foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ
⊢i a --->
   foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp h l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning
    {
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
match l with
| [] => true
| b :: t => b && fold_right t
end)
((fix map (l : list Pattern) : list bool :=
match l with
| [] => []
| a :: t => well_formed a :: map t
end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ
⊢i foldr patt_imp h l --->
foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i a --->
   foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l
using BasicReasoning apply prf_add_assumption; try_wfauto2.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
match l with
| [] => true
| b :: t => b && fold_right t
end)
((fix map (l : list Pattern) : list bool :=
match l with
| [] => []
| a :: t => well_formed a :: map t
end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ
⊢i foldr patt_imp h l --->
foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l
using BasicReasoning assumption. }
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
match l with
| [] => true
| b :: t => b && fold_right t
end)
((fix map (l : list Pattern) : list bool :=
match l with
| [] => []
| a :: t => well_formed a :: map t
end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ
⊢i foldr patt_imp h l --->
foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ
⊢i a --->
   foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp h l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning

    assert (H2 : Γ ⊢i (a ---> foldr patt_imp h l) --->
                     (a ---> foldr patt_imp g (l ++ [h]) --->
                     foldr patt_imp g l)
            using BasicReasoning).
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
match l with
| [] => true
| b :: t => b && fold_right t
end)
((fix map (l : list Pattern) : list bool :=
match l with
| [] => []
| a :: t => well_formed a :: map t
end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ
⊢i foldr patt_imp h l --->
foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ
⊢i a --->
   foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp h l) --->
   a --->
   foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l
using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
   match l with
   | [] => true
   | b :: t => b && fold_right t
   end)
  ((fix map (l : list Pattern) : list bool :=
      match l with
      | [] => []
      | a :: t => well_formed a :: map t
      end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ
⊢i foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ
⊢i a --->
   foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l) --->
   a --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp h l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning
    {
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
match l with
| [] => true
| b :: t => b && fold_right t
end)
((fix map (l : list Pattern) : list bool :=
match l with
| [] => []
| a :: t => well_formed a :: map t
end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ
⊢i foldr patt_imp h l --->
foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ
⊢i a --->
   foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp h l) --->
   a --->
   foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l
using BasicReasoning apply prf_impl_distr_meta;[wf_auto2|wf_auto2|wf_auto2|].
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
match l with
| [] => true
| b :: t => b && fold_right t
end)
((fix map (l : list Pattern) : list bool :=
match l with
| [] => []
| a :: t => well_formed a :: map t
end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ
⊢i foldr patt_imp h l --->
foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ
⊢i a --->
   foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
Γ
⊢i a --->
   foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l
using BasicReasoning apply H1. }
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
match l with
| [] => true
| b :: t => b && fold_right t
end)
((fix map (l : list Pattern) : list bool :=
match l with
| [] => []
| a :: t => well_formed a :: map t
end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ
⊢i foldr patt_imp h l --->
foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ
⊢i a --->
   foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l) --->
   a --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp h l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning

    assert (H3 : Γ ⊢i ((a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l)
                        ---> ((a ---> foldr patt_imp g (l ++ [h])) ---> (a ---> foldr patt_imp g l)))
            using BasicReasoning).
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
match l with
| [] => true
| b :: t => b && fold_right t
end)
((fix map (l : list Pattern) : list bool :=
match l with
| [] => []
| a :: t => well_formed a :: map t
end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ
⊢i foldr patt_imp h l --->
foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ
⊢i a --->
   foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l) --->
   a --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
Γ
⊢i (a --->
    foldr patt_imp g (l ++ [h]) --->
    foldr patt_imp g l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
   match l with
   | [] => true
   | b :: t => b && fold_right t
   end)
  ((fix map (l : list Pattern) : list bool :=
      match l with
      | [] => []
      | a :: t => well_formed a :: map t
      end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ
⊢i foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ
⊢i a --->
   foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l) --->
   a --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l ++ [h]) --->
    foldr patt_imp g l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp h l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning
    {
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
match l with
| [] => true
| b :: t => b && fold_right t
end)
((fix map (l : list Pattern) : list bool :=
match l with
| [] => []
| a :: t => well_formed a :: map t
end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ
⊢i foldr patt_imp h l --->
foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ
⊢i a --->
   foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l) --->
   a --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
Γ
⊢i (a --->
    foldr patt_imp g (l ++ [h]) --->
    foldr patt_imp g l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning apply P2; wf_auto2. }
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
match l with
| [] => true
| b :: t => b && fold_right t
end)
((fix map (l : list Pattern) : list bool :=
match l with
| [] => []
| a :: t => well_formed a :: map t
end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ
⊢i foldr patt_imp h l --->
foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ
⊢i a --->
   foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l) --->
   a --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l ++ [h]) --->
    foldr patt_imp g l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp h l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning

    eapply prf_weaken_conclusion_meta_meta.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
match l with
| [] => true
| b :: t => b && fold_right t
end)
((fix map (l : list Pattern) : list bool :=
match l with
| [] => []
| a :: t => well_formed a :: map t
end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ
⊢i foldr patt_imp h l --->
foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ
⊢i a --->
   foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l) --->
   a --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l ++ [h]) --->
    foldr patt_imp g l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning
well_formed (a ---> foldr patt_imp h l)
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
   match l with
   | [] => true
   | b :: t => b && fold_right t
   end)
  ((fix map (l : list Pattern) : list bool :=
      match l with
      | [] => []
      | a :: t => well_formed a :: map t
      end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ
⊢i foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ
⊢i a --->
   foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l) --->
   a --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l ++ [h]) --->
    foldr patt_imp g l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning
well_formed ?B
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
   match l with
   | [] => true
   | b :: t => b && fold_right t
   end)
  ((fix map (l : list Pattern) : list bool :=
      match l with
      | [] => []
      | a :: t => well_formed a :: map t
      end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ
⊢i foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ
⊢i a --->
   foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l) --->
   a --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l ++ [h]) --->
    foldr patt_imp g l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning
well_formed
  ((a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l)
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
   match l with
   | [] => true
   | b :: t => b && fold_right t
   end)
  ((fix map (l : list Pattern) : list bool :=
      match l with
      | [] => []
      | a :: t => well_formed a :: map t
      end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ
⊢i foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ
⊢i a --->
   foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l) --->
   a --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l ++ [h]) --->
    foldr patt_imp g l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning
Γ
⊢i ?B --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
   match l with
   | [] => true
   | b :: t => b && fold_right t
   end)
  ((fix map (l : list Pattern) : list bool :=
      match l with
      | [] => []
      | a :: t => well_formed a :: map t
      end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ
⊢i foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ
⊢i a --->
   foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l) --->
   a --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l ++ [h]) --->
    foldr patt_imp g l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning
Γ ⊢i (a ---> foldr patt_imp h l) ---> ?B
using BasicReasoning
    4: apply H3.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
match l with
| [] => true
| b :: t => b && fold_right t
end)
((fix map (l : list Pattern) : list bool :=
match l with
| [] => []
| a :: t => well_formed a :: map t
end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ
⊢i foldr patt_imp h l --->
foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ
⊢i a --->
   foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l) --->
   a --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l ++ [h]) --->
    foldr patt_imp g l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning
well_formed (a ---> foldr patt_imp h l)
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
   match l with
   | [] => true
   | b :: t => b && fold_right t
   end)
  ((fix map (l : list Pattern) : list bool :=
      match l with
      | [] => []
      | a :: t => well_formed a :: map t
      end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ
⊢i foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ
⊢i a --->
   foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l) --->
   a --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l ++ [h]) --->
    foldr patt_imp g l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning
well_formed
  (a --->
   foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l)
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
   match l with
   | [] => true
   | b :: t => b && fold_right t
   end)
  ((fix map (l : list Pattern) : list bool :=
      match l with
      | [] => []
      | a :: t => well_formed a :: map t
      end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ
⊢i foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ
⊢i a --->
   foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l) --->
   a --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l ++ [h]) --->
    foldr patt_imp g l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning
well_formed
  ((a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l)
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
   match l with
   | [] => true
   | b :: t => b && fold_right t
   end)
  ((fix map (l : list Pattern) : list bool :=
      match l with
      | [] => []
      | a :: t => well_formed a :: map t
      end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ
⊢i foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ
⊢i a --->
   foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l) --->
   a --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l ++ [h]) --->
    foldr patt_imp g l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp h l) --->
   a --->
   foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l
using BasicReasoning 4: apply H2.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
match l with
| [] => true
| b :: t => b && fold_right t
end)
((fix map (l : list Pattern) : list bool :=
match l with
| [] => []
| a :: t => well_formed a :: map t
end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ
⊢i foldr patt_imp h l --->
foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ
⊢i a --->
   foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l) --->
   a --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l ++ [h]) --->
    foldr patt_imp g l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning
well_formed (a ---> foldr patt_imp h l)
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
   match l with
   | [] => true
   | b :: t => b && fold_right t
   end)
  ((fix map (l : list Pattern) : list bool :=
      match l with
      | [] => []
      | a :: t => well_formed a :: map t
      end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ
⊢i foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ
⊢i a --->
   foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l) --->
   a --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l ++ [h]) --->
    foldr patt_imp g l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning
well_formed
  (a --->
   foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l)
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool :=
   match l with
   | [] => true
   | b :: t => b && fold_right t
   end)
  ((fix map (l : list Pattern) : list bool :=
      match l with
      | [] => []
      | a :: t => well_formed a :: map t
      end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ
⊢i foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ
⊢i a --->
   foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l) --->
   a --->
   foldr patt_imp g (l ++ [h]) --->
   foldr patt_imp g l using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l ++ [h]) --->
    foldr patt_imp g l) --->
   (a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l using BasicReasoning
well_formed
  ((a ---> foldr patt_imp g (l ++ [h])) --->
   a ---> foldr patt_imp g l) all: wf_auto2.
Defined.

Lemma prf_add_lemma_under_implication_meta {Σ : Signature} Γ l g h i:
  Pattern.wf l ->
  well_formed g ->
  well_formed h ->
  Γ ⊢i (foldr patt_imp h l) using i ->
  Γ ⊢i ((foldr patt_imp g (l ++ [h])) ---> (foldr patt_imp g l)) using i.
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
Pattern.wf l
→ well_formed g
  → well_formed h
    → Γ ⊢i foldr patt_imp h l using i
      → Γ
        ⊢i foldr patt_imp g (l ++ [h]) --->
           foldr patt_imp g l using i
Proof.
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
Pattern.wf l
→ well_formed g
  → well_formed h
    → Γ ⊢i foldr patt_imp h l using i
      → Γ
        ⊢i foldr patt_imp g (l ++ [h]) --->
           foldr patt_imp g l using i
  intros WFl WFg WGh H.
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
Γ
⊢i foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l
using i
  eapply MP.
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
Γ
⊢i ?ϕ₁ --->
   foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l
using i
  {
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
Γ ⊢i ?ϕ₁ using i apply H. }
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
Γ
⊢i foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l
using i
  {
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
Γ
⊢i foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l
using i useBasicReasoning.
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
Γ
⊢i foldr patt_imp h l --->
   foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l
using BasicReasoning apply prf_add_lemma_under_implication.
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
Pattern.wf l
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
well_formed g
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
well_formed h all: wf_auto2. }
Defined.

Lemma prf_add_lemma_under_implication_meta_meta {Σ : Signature} Γ l g h i:
  Pattern.wf l ->
  well_formed g ->
  well_formed h ->
  Γ ⊢i (foldr patt_imp h l) using i ->
  Γ ⊢i (foldr patt_imp g (l ++ [h])) using i ->
  Γ ⊢i (foldr patt_imp g l) using i.
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
Pattern.wf l
→ well_formed g
  → well_formed h
    → Γ ⊢i foldr patt_imp h l using i
      → Γ ⊢i foldr patt_imp g (l ++ [h]) using i
        → Γ ⊢i foldr patt_imp g l using i
Proof.
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
Pattern.wf l
→ well_formed g
  → well_formed h
    → Γ ⊢i foldr patt_imp h l using i
      → Γ ⊢i foldr patt_imp g (l ++ [h]) using i
        → Γ ⊢i foldr patt_imp g l using i
  intros WFl WFg WGh H H0.
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
H0: Γ ⊢i foldr patt_imp g (l ++ [h]) using i
Γ ⊢i foldr patt_imp g l using i
  eapply MP.
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
H0: Γ ⊢i foldr patt_imp g (l ++ [h]) using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
H0: Γ ⊢i foldr patt_imp g (l ++ [h]) using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp g l using i
  {
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
H0: Γ ⊢i foldr patt_imp g (l ++ [h]) using i
Γ ⊢i ?ϕ₁ using i apply H0. }
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
H0: Γ ⊢i foldr patt_imp g (l ++ [h]) using i
Γ
⊢i foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l
using i
  {
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
H0: Γ ⊢i foldr patt_imp g (l ++ [h]) using i
Γ
⊢i foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l
using i apply prf_add_lemma_under_implication_meta.
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
H0: Γ ⊢i foldr patt_imp g (l ++ [h]) using i
Pattern.wf l
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
H0: Γ ⊢i foldr patt_imp g (l ++ [h]) using i
well_formed g
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
H0: Γ ⊢i foldr patt_imp g (l ++ [h]) using i
well_formed h
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
H0: Γ ⊢i foldr patt_imp g (l ++ [h]) using i
Γ ⊢i foldr patt_imp h l using i 4: apply H.
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
H0: Γ ⊢i foldr patt_imp g (l ++ [h]) using i
Pattern.wf l
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
H0: Γ ⊢i foldr patt_imp g (l ++ [h]) using i
well_formed g
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
H0: Γ ⊢i foldr patt_imp g (l ++ [h]) using i
well_formed h all: wf_auto2. }
Defined.

Lemma mlGoal_assert {Σ : Signature} Γ l name g h i:
  well_formed h ->
  mkMLGoal Σ Γ l h i ->
  mkMLGoal Σ Γ (l ++ [mkNH _ name h]) g i ->
  mkMLGoal Σ Γ l g i.
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
well_formed h
→ Γ Ⱶ
  l--------------------------------------
  h
  using i
  
  → Γ Ⱶ
    l ++ (name ∶ h,
          )--------------------------------------
    g
    using i
    
    → Γ Ⱶ
    l--------------------------------------
    g
    using i
    
Proof.
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
well_formed h
→ Γ Ⱶ
  l--------------------------------------
  h
  using i
  
  → Γ Ⱶ
    l ++ (name ∶ h,
          )--------------------------------------
    g
    using i
    
    → Γ Ⱶ
    l--------------------------------------
    g
    using i
    
  intros wfh H1 H2.
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: Γ Ⱶ
l--------------------------------------
h
using i

H2: Γ Ⱶ
l ++ (name ∶ h,
      )--------------------------------------
g
using i

Γ Ⱶ
l--------------------------------------
g
using i

  unfold of_MLGoal in *.
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l--------------------------------------
      h
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l--------------------------------------
           h
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       l--------------------------------------
       h
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l--------------------------------------
             h
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l--------------------------------------
                h
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             l--------------------------------------
             h
             using i
             )
H2: well_formed
  (mlConclusion
     (Γ Ⱶ
      l ++ (name ∶ h,
            )--------------------------------------
      g
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l ++ (name ∶ h,
                 )--------------------------------------
           g
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       l ++ (name ∶ h,
             )--------------------------------------
       g
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l ++ (name ∶ h,
                   )--------------------------------------
             g
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l ++ (name ∶ h,
                      )--------------------------------------
                g
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             l ++ (name ∶ h,
                   )--------------------------------------
             g
             using i
             )
well_formed
  (mlConclusion
     (Γ Ⱶ
      l--------------------------------------
      g
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l--------------------------------------
           g
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       l--------------------------------------
       g
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l--------------------------------------
             g
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l--------------------------------------
                g
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             l--------------------------------------
             g
             using i
             ) simpl in *.
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g
→ Pattern.wf (patterns_of (l ++ (name ∶ h,
                        )))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l ++ (name ∶ h,
                        ))) using i
well_formed g
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp g (patterns_of l) using i
  intros wfg wfl.
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g
→ Pattern.wf (patterns_of (l ++ (name ∶ h,
                        )))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l ++ (name ∶ h,
                        ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp g (patterns_of l) using i
  eapply prf_add_lemma_under_implication_meta_meta.
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g
→ Pattern.wf (patterns_of (l ++ (name ∶ h,
                        )))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l ++ (name ∶ h,
                        ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g
→ Pattern.wf (patterns_of (l ++ (name ∶ h,
                        )))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l ++ (name ∶ h,
                        ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed g
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g
→ Pattern.wf (patterns_of (l ++ (name ∶ h,
                        )))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l ++ (name ∶ h,
                        ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed ?h
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g
→ Pattern.wf (patterns_of (l ++ (name ∶ h,
                        )))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l ++ (name ∶ h,
                        ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp ?h (patterns_of l) using i
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g
→ Pattern.wf (patterns_of (l ++ (name ∶ h,
                        )))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l ++ (name ∶ h,
                        ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp g (patterns_of l ++ [?h]) using i
  4: apply H1.
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g
→ Pattern.wf (patterns_of (l ++ (name ∶ h,
                        )))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l ++ (name ∶ h,
                        ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g
→ Pattern.wf (patterns_of (l ++ (name ∶ h,
                        )))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l ++ (name ∶ h,
                        ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed g
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g
→ Pattern.wf (patterns_of (l ++ (name ∶ h,
                        )))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l ++ (name ∶ h,
                        ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed h
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g
→ Pattern.wf (patterns_of (l ++ (name ∶ h,
                        )))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l ++ (name ∶ h,
                        ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed h
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g
→ Pattern.wf (patterns_of (l ++ (name ∶ h,
                        )))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l ++ (name ∶ h,
                        ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g
→ Pattern.wf (patterns_of (l ++ (name ∶ h,
                        )))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l ++ (name ∶ h,
                        ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp g (patterns_of l ++ [h]) using i 6: unfold patterns_of in H2; rewrite map_app in H2; apply H2.
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g
→ Pattern.wf (patterns_of (l ++ (name ∶ h,
                        )))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l ++ (name ∶ h,
                        ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g
→ Pattern.wf (patterns_of (l ++ (name ∶ h,
                        )))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l ++ (name ∶ h,
                        ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed g
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g
→ Pattern.wf (patterns_of (l ++ (name ∶ h,
                        )))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l ++ (name ∶ h,
                        ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed h
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g
→ Pattern.wf (patterns_of (l ++ (name ∶ h,
                        )))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l ++ (name ∶ h,
                        ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed h
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g
→ Pattern.wf (patterns_of (l ++ (name ∶ h,
                        )))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l ++ (name ∶ h,
                        ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp h (patterns_of l) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
H2: well_formed g
→ Pattern.wf
    (map nh_patt l ++ map nh_patt (name ∶ h,
                        ))
  → Γ
    ⊢i foldr patt_imp g
         (map nh_patt l ++
          map nh_patt (name ∶ h,
                       )) using i
well_formed g
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp h (patterns_of l) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
H2: well_formed g
→ Pattern.wf
    (map nh_patt l ++ map nh_patt (name ∶ h,
                        ))
  → Γ
    ⊢i foldr patt_imp g
         (map nh_patt l ++
          map nh_patt (name ∶ h,
                       )) using i
Pattern.wf (map nh_patt l ++ map nh_patt (name ∶ h,
                        )) all: try assumption.
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp h (patterns_of l) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
H2: well_formed g
→ Pattern.wf
    (map nh_patt l ++ map nh_patt (name ∶ h,
                        ))
  → Γ
    ⊢i foldr patt_imp g
         (map nh_patt l ++
          map nh_patt (name ∶ h,
                       )) using i
Pattern.wf (map nh_patt l ++ map nh_patt (name ∶ h,
                                          ))
  {
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp h (patterns_of l) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
H2: well_formed g
→ Pattern.wf
    (map nh_patt l ++ map nh_patt (name ∶ h,
                        ))
  → Γ
    ⊢i foldr patt_imp g
         (map nh_patt l ++
          map nh_patt (name ∶ h,
                       )) using i
Pattern.wf (map nh_patt l ++ map nh_patt (name ∶ h,
                                          )) abstract (
      unfold Pattern.wf;
      rewrite map_app;
      rewrite foldr_app;
      simpl;
      rewrite wfh;
      simpl;
      exact wfl
    ).
  }
Defined.

Lemma prf_add_lemma_under_implication_generalized {Σ : Signature} Γ l1 l2 g h:
  Pattern.wf l1 ->
  Pattern.wf l2 ->
  well_formed g ->
  well_formed h ->
  Γ ⊢i ((foldr patt_imp h l1) ---> ((foldr patt_imp g (l1 ++ [h] ++ l2)) ---> (foldr patt_imp g (l1 ++ l2))))
  using BasicReasoning.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
Pattern.wf l1
→ Pattern.wf l2
  → well_formed g
    → well_formed h
      → Γ
        ⊢i foldr patt_imp h l1 --->
           foldr patt_imp g (l1 ++ [h] ++ l2) --->
           foldr patt_imp g (l1 ++ l2)
        using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
Pattern.wf l1
→ Pattern.wf l2
  → well_formed g
    → well_formed h
      → Γ
        ⊢i foldr patt_imp h l1 --->
           foldr patt_imp g (l1 ++ [h] ++ l2) --->
           foldr patt_imp g (l1 ++ l2)
        using BasicReasoning
  intros wfl1 wfl2 wfg wfh.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
wfl1: Pattern.wf l1
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2) using BasicReasoning
  induction l1; simpl.
Σ: Signature
Γ: Theory
l2: list Pattern
g, h: Pattern
wfl1: Pattern.wf []
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
Γ
⊢i h --->
   (h ---> foldr patt_imp g l2) --->
   foldr patt_imp g l2 using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfl1: Pattern.wf (a :: l1)
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Pattern.wf l1
→ Γ
  ⊢i foldr patt_imp h l1 --->
     foldr patt_imp g (l1 ++ [h] ++ l2) --->
     foldr patt_imp g (l1 ++ l2)
  using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp h l1) --->
   (a ---> foldr patt_imp g (l1 ++ h :: l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning
  -
Σ: Signature
Γ: Theory
l2: list Pattern
g, h: Pattern
wfl1: Pattern.wf []
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
Γ
⊢i h --->
   (h ---> foldr patt_imp g l2) --->
   foldr patt_imp g l2 using BasicReasoning apply modus_ponens; wf_auto2.
  -
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfl1: Pattern.wf (a :: l1)
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Pattern.wf l1
→ Γ
  ⊢i foldr patt_imp h l1 --->
     foldr patt_imp g (l1 ++ [h] ++ l2) --->
     foldr patt_imp g (l1 ++ l2)
  using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp h l1) --->
   (a ---> foldr patt_imp g (l1 ++ h :: l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning pose proof (wfal1 := wfl1).
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfl1: Pattern.wf (a :: l1)
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Pattern.wf l1
→ Γ
  ⊢i foldr patt_imp h l1 --->
     foldr patt_imp g (l1 ++ [h] ++ l2) --->
     foldr patt_imp g (l1 ++ l2)
  using BasicReasoning
wfal1: Pattern.wf (a :: l1)
Γ
⊢i (a ---> foldr patt_imp h l1) --->
   (a ---> foldr patt_imp g (l1 ++ h :: l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning
    unfold Pattern.wf in wfl1.
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfl1: foldr andb true (map well_formed (a :: l1))
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Pattern.wf l1
→ Γ
  ⊢i foldr patt_imp h l1 --->
     foldr patt_imp g (l1 ++ [h] ++ l2) --->
     foldr patt_imp g (l1 ++ l2)
  using BasicReasoning
wfal1: Pattern.wf (a :: l1)
Γ
⊢i (a ---> foldr patt_imp h l1) --->
   (a ---> foldr patt_imp g (l1 ++ h :: l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning simpl in wfl1.
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfl1: well_formed a &&
foldr andb true (map well_formed l1)
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Pattern.wf l1
→ Γ
  ⊢i foldr patt_imp h l1 --->
     foldr patt_imp g (l1 ++ [h] ++ l2) --->
     foldr patt_imp g (l1 ++ l2)
  using BasicReasoning
wfal1: Pattern.wf (a :: l1)
Γ
⊢i (a ---> foldr patt_imp h l1) --->
   (a ---> foldr patt_imp g (l1 ++ h :: l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning apply andb_prop in wfl1.
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfl1: well_formed a = true
∧ foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Pattern.wf l1
→ Γ
  ⊢i foldr patt_imp h l1 --->
     foldr patt_imp g (l1 ++ [h] ++ l2) --->
     foldr patt_imp g (l1 ++ l2)
  using BasicReasoning
wfal1: Pattern.wf (a :: l1)
Γ
⊢i (a ---> foldr patt_imp h l1) --->
   (a ---> foldr patt_imp g (l1 ++ h :: l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning destruct wfl1 as [wfa wfl1].
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Pattern.wf l1
→ Γ
  ⊢i foldr patt_imp h l1 --->
     foldr patt_imp g (l1 ++ [h] ++ l2) --->
     foldr patt_imp g (l1 ++ l2)
  using BasicReasoning
wfal1: Pattern.wf (a :: l1)
Γ
⊢i (a ---> foldr patt_imp h l1) --->
   (a ---> foldr patt_imp g (l1 ++ h :: l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning
    specialize (IHl1 wfl1).
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
wfal1: Pattern.wf (a :: l1)
Γ
⊢i (a ---> foldr patt_imp h l1) --->
   (a ---> foldr patt_imp g (l1 ++ h :: l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning
    assert (H1: Γ ⊢i a ---> foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning).
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
wfal1: Pattern.wf (a :: l1)
Γ
⊢i a --->
   foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ
⊢i a --->
   foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp h l1) --->
   (a ---> foldr patt_imp g (l1 ++ h :: l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning
    {
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
wfal1: Pattern.wf (a :: l1)
Γ
⊢i a --->
   foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2) using BasicReasoning apply prf_add_assumption; try_wfauto2.
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
wfal1: Pattern.wf (a :: l1)
Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2) using BasicReasoning assumption. }
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ
⊢i a --->
   foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp h l1) --->
   (a ---> foldr patt_imp g (l1 ++ h :: l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning
    assert (H2 : Γ ⊢i (a ---> foldr patt_imp h l1) ---> (a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2)) using BasicReasoning).
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ
⊢i a --->
   foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp h l1) --->
   a --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ
⊢i a --->
   foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l1) --->
   a --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp h l1) --->
   (a ---> foldr patt_imp g (l1 ++ h :: l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning
    {
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ
⊢i a --->
   foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp h l1) --->
   a --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2) using BasicReasoning apply prf_impl_distr_meta;[wf_auto2|wf_auto2|wf_auto2|].
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ
⊢i a --->
   foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
Γ
⊢i a --->
   foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2) using BasicReasoning exact H1. }
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ
⊢i a --->
   foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l1) --->
   a --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp h l1) --->
   (a ---> foldr patt_imp g (l1 ++ h :: l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning
    assert (H3 : Γ ⊢i ((a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2))
                        ---> ((a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) ---> (a ---> foldr patt_imp g (l1 ++ l2)))) using BasicReasoning).
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ
⊢i a --->
   foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l1) --->
   a --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
Γ
⊢i (a --->
    foldr patt_imp g (l1 ++ [h] ++ l2) --->
    foldr patt_imp g (l1 ++ l2)) --->
   (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ
⊢i a --->
   foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l1) --->
   a --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l1 ++ [h] ++ l2) --->
    foldr patt_imp g (l1 ++ l2)) --->
   (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp h l1) --->
   (a ---> foldr patt_imp g (l1 ++ h :: l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning
    {
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ
⊢i a --->
   foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l1) --->
   a --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
Γ
⊢i (a --->
    foldr patt_imp g (l1 ++ [h] ++ l2) --->
    foldr patt_imp g (l1 ++ l2)) --->
   (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning apply P2; wf_auto2. }
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ
⊢i a --->
   foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l1) --->
   a --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l1 ++ [h] ++ l2) --->
    foldr patt_imp g (l1 ++ l2)) --->
   (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp h l1) --->
   (a ---> foldr patt_imp g (l1 ++ h :: l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning

    eapply prf_weaken_conclusion_meta_meta.
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ
⊢i a --->
   foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l1) --->
   a --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l1 ++ [h] ++ l2) --->
    foldr patt_imp g (l1 ++ l2)) --->
   (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning
well_formed (a ---> foldr patt_imp h l1)
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ
⊢i a --->
   foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l1) --->
   a --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l1 ++ [h] ++ l2) --->
    foldr patt_imp g (l1 ++ l2)) --->
   (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning
well_formed ?B
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ
⊢i a --->
   foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l1) --->
   a --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l1 ++ [h] ++ l2) --->
    foldr patt_imp g (l1 ++ l2)) --->
   (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning
well_formed
  ((a ---> foldr patt_imp g (l1 ++ h :: l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2))
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ
⊢i a --->
   foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l1) --->
   a --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l1 ++ [h] ++ l2) --->
    foldr patt_imp g (l1 ++ l2)) --->
   (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning
Γ
⊢i ?B --->
   (a ---> foldr patt_imp g (l1 ++ h :: l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ
⊢i a --->
   foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l1) --->
   a --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l1 ++ [h] ++ l2) --->
    foldr patt_imp g (l1 ++ l2)) --->
   (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning
Γ ⊢i (a ---> foldr patt_imp h l1) ---> ?B
using BasicReasoning
    4: apply H3.
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ
⊢i a --->
   foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l1) --->
   a --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l1 ++ [h] ++ l2) --->
    foldr patt_imp g (l1 ++ l2)) --->
   (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning
well_formed (a ---> foldr patt_imp h l1)
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ
⊢i a --->
   foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l1) --->
   a --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l1 ++ [h] ++ l2) --->
    foldr patt_imp g (l1 ++ l2)) --->
   (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning
well_formed
  (a --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2))
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ
⊢i a --->
   foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l1) --->
   a --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l1 ++ [h] ++ l2) --->
    foldr patt_imp g (l1 ++ l2)) --->
   (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning
well_formed
  ((a ---> foldr patt_imp g (l1 ++ h :: l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2))
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ
⊢i a --->
   foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l1) --->
   a --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l1 ++ [h] ++ l2) --->
    foldr patt_imp g (l1 ++ l2)) --->
   (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp h l1) --->
   a --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2) using BasicReasoning 4: assumption.
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ
⊢i a --->
   foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l1) --->
   a --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l1 ++ [h] ++ l2) --->
    foldr patt_imp g (l1 ++ l2)) --->
   (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning
well_formed (a ---> foldr patt_imp h l1)
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ
⊢i a --->
   foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l1) --->
   a --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l1 ++ [h] ++ l2) --->
    foldr patt_imp g (l1 ++ l2)) --->
   (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning
well_formed
  (a --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2))
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ
⊢i a --->
   foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H2: Γ
⊢i (a ---> foldr patt_imp h l1) --->
   a --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2)
using BasicReasoning
H3: Γ
⊢i (a --->
    foldr patt_imp g (l1 ++ [h] ++ l2) --->
    foldr patt_imp g (l1 ++ l2)) --->
   (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)
using BasicReasoning
well_formed
  ((a ---> foldr patt_imp g (l1 ++ h :: l2)) --->
   a ---> foldr patt_imp g (l1 ++ l2)) all: wf_auto2.
Defined.

Lemma prf_add_lemma_under_implication_generalized_meta {Σ : Signature} Γ l1 l2 g h i:
  Pattern.wf l1 ->
  Pattern.wf l2 ->
  well_formed g ->
  well_formed h ->
  Γ ⊢i (foldr patt_imp h l1) using i ->
  Γ ⊢i ((foldr patt_imp g (l1 ++ [h] ++ l2)) ---> (foldr patt_imp g (l1 ++ l2))) using i.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
Pattern.wf l1
→ Pattern.wf l2
  → well_formed g
    → well_formed h
      → Γ ⊢i foldr patt_imp h l1 using i
        → Γ
          ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) --->
             foldr patt_imp g (l1 ++ l2) using i
Proof.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
Pattern.wf l1
→ Pattern.wf l2
  → well_formed g
    → well_formed h
      → Γ ⊢i foldr patt_imp h l1 using i
        → Γ
          ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) --->
             foldr patt_imp g (l1 ++ l2) using i
  intros WFl1 WFl2 WFg WGh H.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
Γ
⊢i foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2) using i
  eapply MP.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
Γ
⊢i ?ϕ₁ --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2) using i
  {
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
Γ ⊢i ?ϕ₁ using i apply H. }
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2) using i
  {
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2) using i useBasicReasoning.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
Γ
⊢i foldr patt_imp h l1 --->
   foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2) using BasicReasoning
    apply prf_add_lemma_under_implication_generalized; wf_auto2.
  }
Defined.

Lemma prf_add_lemma_under_implication_generalized_meta_meta {Σ : Signature} Γ l1 l2 g h i:
  Pattern.wf l1 ->
  Pattern.wf l2 ->
  well_formed g ->
  well_formed h ->
  Γ ⊢i (foldr patt_imp h l1) using i ->
  Γ ⊢i (foldr patt_imp g (l1 ++ [h] ++ l2)) using i ->
  Γ ⊢i (foldr patt_imp g (l1 ++ l2)) using i.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
Pattern.wf l1
→ Pattern.wf l2
  → well_formed g
    → well_formed h
      → Γ ⊢i foldr patt_imp h l1 using i
        → Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2)
          using i
          → Γ ⊢i foldr patt_imp g (l1 ++ l2) using i
Proof.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
Pattern.wf l1
→ Pattern.wf l2
  → well_formed g
    → well_formed h
      → Γ ⊢i foldr patt_imp h l1 using i
        → Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2)
          using i
          → Γ ⊢i foldr patt_imp g (l1 ++ l2) using i
  intros WFl1 WFl2 WFg WGh H H0.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i
Γ ⊢i foldr patt_imp g (l1 ++ l2) using i
  eapply MP.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp g (l1 ++ l2) using i
  {
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i
Γ ⊢i ?ϕ₁ using i apply H0. }
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i
Γ
⊢i foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2) using i
  {
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i
Γ
⊢i foldr patt_imp g (l1 ++ [h] ++ l2) --->
   foldr patt_imp g (l1 ++ l2) using i apply prf_add_lemma_under_implication_generalized_meta.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i
Pattern.wf l1
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i
Pattern.wf l2
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i
well_formed g
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i
well_formed h
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i
Γ ⊢i foldr patt_imp h l1 using i
    5: apply H.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i
Pattern.wf l1
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i
Pattern.wf l2
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i
well_formed g
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i
well_formed h all: wf_auto2.
  }
Defined.

Lemma mlGoal_assert_generalized {Σ : Signature} Γ l1 l2 name g h i:
  well_formed h ->
  mkMLGoal Σ Γ l1 h i ->
  mkMLGoal Σ Γ (l1 ++ [mkNH _ name h] ++ l2) g i ->
  mkMLGoal Σ Γ (l1 ++ l2) g i.
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
well_formed h
→ Γ Ⱶ
  l1--------------------------------------
  h
  using i
  
  → Γ Ⱶ
    l1 ++ (name ∶ h,
           ) ++ l2--------------------------------------
    g
    using i
    
    → Γ Ⱶ
    l1 ++ l2--------------------------------------
    g
    using i
    
Proof.
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
well_formed h
→ Γ Ⱶ
  l1--------------------------------------
  h
  using i
  
  → Γ Ⱶ
    l1 ++ (name ∶ h,
           ) ++ l2--------------------------------------
    g
    using i
    
    → Γ Ⱶ
    l1 ++ l2--------------------------------------
    g
    using i
    
  intros wfh H1 H2.
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: Γ Ⱶ
l1--------------------------------------
h
using i

H2: Γ Ⱶ
l1 ++ (name ∶ h,
       ) ++ l2--------------------------------------
g
using i

Γ Ⱶ
l1 ++ l2--------------------------------------
g
using i

  unfold of_MLGoal in *.
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l1--------------------------------------
      h
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l1--------------------------------------
           h
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       l1--------------------------------------
       h
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l1--------------------------------------
             h
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l1--------------------------------------
                h
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             l1--------------------------------------
             h
             using i
             )
H2: well_formed
  (mlConclusion
     (Γ Ⱶ
      l1 ++ (name ∶ h,
             ) ++ l2--------------------------------------
      g
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l1 ++ (name ∶ h,
                  ) ++ l2--------------------------------------
           g
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       l1 ++ (name ∶ h,
              ) ++ l2--------------------------------------
       g
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l1 ++ (name ∶ h,
                    ) ++ l2--------------------------------------
             g
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l1 ++ (name ∶ h,
                       ) ++ l2--------------------------------------
                g
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             l1 ++ (name ∶ h,
                    ) ++ l2--------------------------------------
             g
             using i
             )
well_formed
  (mlConclusion
     (Γ Ⱶ
      l1 ++ l2--------------------------------------
      g
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l1 ++ l2--------------------------------------
           g
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       l1 ++ l2--------------------------------------
       g
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l1 ++ l2--------------------------------------
             g
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l1 ++ l2--------------------------------------
                g
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             l1 ++ l2--------------------------------------
             g
             using i
             ) simpl in *.
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
well_formed g
→ Pattern.wf (patterns_of (l1 ++ l2))
  → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ l2))
    using i
  intros wfg wfl1l2.
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ l2)) using i
  unfold patterns_of.
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2)) using i
  rewrite map_app.
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Γ
⊢i foldr patt_imp g (map nh_patt l1 ++ map nh_patt l2)
using i
  eapply prf_add_lemma_under_implication_generalized_meta_meta.
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Pattern.wf (map nh_patt l1)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Pattern.wf (map nh_patt l2)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
well_formed g
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
well_formed ?h
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Γ ⊢i foldr patt_imp ?h (map nh_patt l1) using i
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Γ
⊢i foldr patt_imp g
     (map nh_patt l1 ++ [?h] ++ map nh_patt l2)
using i
  5: apply H1.
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Pattern.wf (map nh_patt l1)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Pattern.wf (map nh_patt l2)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
well_formed g
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
well_formed h
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
well_formed h
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Pattern.wf (patterns_of l1)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Γ
⊢i foldr patt_imp g
     (map nh_patt l1 ++ [h] ++ map nh_patt l2) using i 7: unfold patterns_of in H2; rewrite map_app in H2; apply H2.
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Pattern.wf (map nh_patt l1)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Pattern.wf (map nh_patt l2)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
well_formed g
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
well_formed h
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
well_formed h
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Pattern.wf (patterns_of l1)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
H2: well_formed g
→ Pattern.wf
    (map nh_patt l1 ++
     map nh_patt ((name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (map nh_patt l1 ++
          map nh_patt ((name ∶ h) :: l2)) using i
well_formed g
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
H2: well_formed g
→ Pattern.wf
    (map nh_patt l1 ++
     map nh_patt ((name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (map nh_patt l1 ++
          map nh_patt ((name ∶ h) :: l2)) using i
Pattern.wf
  (map nh_patt l1 ++ map nh_patt ((name ∶ h) :: l2)) all: try assumption.
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Pattern.wf (map nh_patt l1)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Pattern.wf (map nh_patt l2)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Pattern.wf (patterns_of l1)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
H2: well_formed g
→ Pattern.wf
    (map nh_patt l1 ++
     map nh_patt ((name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (map nh_patt l1 ++
          map nh_patt ((name ∶ h) :: l2)) using i
Pattern.wf
  (map nh_patt l1 ++ map nh_patt ((name ∶ h) :: l2))
  {
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Pattern.wf (map nh_patt l1) abstract (
        apply (wf_take (length (patterns_of l1))) in wfl1l2;
        unfold patterns_of in wfl1l2;
        rewrite map_app in wfl1l2;
        rewrite take_app in wfl1l2;
        exact wfl1l2
    ).
  }
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Pattern.wf (map nh_patt l2)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Pattern.wf (patterns_of l1)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
H2: well_formed g
→ Pattern.wf
    (map nh_patt l1 ++
     map nh_patt ((name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (map nh_patt l1 ++
          map nh_patt ((name ∶ h) :: l2)) using i
Pattern.wf
  (map nh_patt l1 ++ map nh_patt ((name ∶ h) :: l2))
  {
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Pattern.wf (map nh_patt l2) abstract (
        apply (wf_drop (length (patterns_of l1))) in wfl1l2;
        unfold patterns_of in wfl1l2;
        rewrite map_app in wfl1l2;
        rewrite drop_app in wfl1l2;
        exact wfl1l2
    ).
  }
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Pattern.wf (patterns_of l1)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
H2: well_formed g
→ Pattern.wf
    (map nh_patt l1 ++
     map nh_patt ((name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (map nh_patt l1 ++
          map nh_patt ((name ∶ h) :: l2)) using i
Pattern.wf
  (map nh_patt l1 ++ map nh_patt ((name ∶ h) :: l2))
  {
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
H2: well_formed g
→ Pattern.wf
    (patterns_of (l1 ++ (name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l1 ++ (name ∶ h) :: l2))
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Pattern.wf (patterns_of l1) abstract (
        apply (wf_take (length (patterns_of l1))) in wfl1l2;
        unfold patterns_of in wfl1l2;
        rewrite map_app in wfl1l2;
        rewrite take_app in wfl1l2;
        exact wfl1l2
    ).
  }
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
H2: well_formed g
→ Pattern.wf
    (map nh_patt l1 ++
     map nh_patt ((name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (map nh_patt l1 ++
          map nh_patt ((name ∶ h) :: l2)) using i
Pattern.wf
  (map nh_patt l1 ++ map nh_patt ((name ∶ h) :: l2))
  {
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h
→ Pattern.wf (patterns_of l1)
  → Γ ⊢i foldr patt_imp h (patterns_of l1)
    using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
H2: well_formed g
→ Pattern.wf
    (map nh_patt l1 ++
     map nh_patt ((name ∶ h) :: l2))
  → Γ
    ⊢i foldr patt_imp g
         (map nh_patt l1 ++
          map nh_patt ((name ∶ h) :: l2)) using i
Pattern.wf
  (map nh_patt l1 ++ map nh_patt ((name ∶ h) :: l2))
    abstract(
      pose proof (wfl1 := wf_take (length (patterns_of l1)) _ wfl1l2);
      unfold patterns_of in wfl1;
      rewrite map_app in wfl1;
      rewrite take_app in wfl1;
      pose proof (wfl2 := wf_drop (length (patterns_of l1)) _ wfl1l2);
      unfold patterns_of in wfl2;
      rewrite map_app in wfl2;
      rewrite drop_app in wfl2;
      unfold Pattern.wf; rewrite map_app; rewrite foldr_app;
      simpl; rewrite wfh; unfold Pattern.wf in wfl2; rewrite wfl2;
      simpl; exact wfl1
    ).
  }
Defined.

Tactic Notation "_mlAssert_nocheck" "(" constr(name) ":" constr(t) ")" :=
  match goal with
  | |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm ?Ctx ?l ?g ?i) =>
    let Hwf := fresh "Hwf" in
    assert (Hwf : well_formed t);
    [idtac|
      let H := fresh "H" in
      assert (H : @mkMLGoal Sgm Ctx l t i);
      [ | (eapply (@mlGoal_assert Sgm Ctx l name g t i Hwf H); rewrite [_ ++ _]/=; clear H)]
    ]
  end.


(* TODO: make this bind tigther. *)
Tactic Notation "mlAssert" "(" constr(name) ":" constr(t) ")" :=
  _ensureProofMode;
  _failIfUsed name;
  _mlAssert_nocheck (name : t)
.


Tactic Notation "mlAssert" "(" constr (t) ")" :=
  _ensureProofMode;
  let hyps := _getHypNames in
  let name := eval lazy in (fresh hyps) in
  mlAssert (name : (t)).

Local Example ex_mlAssert {Σ : Signature} Γ a:
  well_formed a ->
  Γ ⊢i (a ---> a ---> a) using BasicReasoning.
Σ: Signature
Γ: Theory
a: Pattern
well_formed a
→ Γ ⊢i a ---> a ---> a using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
a: Pattern
well_formed a
→ Γ ⊢i a ---> a ---> a using BasicReasoning
  intros wfa.
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ ⊢i a ---> a ---> a using BasicReasoning
  toMLGoal.
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
well_formed (a ---> a ---> a)
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ
a ---> a ---> a
using BasicReasoning

  {
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
well_formed (a ---> a ---> a) wf_auto2. }
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ
a ---> a ---> a
using BasicReasoning

  mlIntro "H0".
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ
"H0" ∶ a,
--------------------------------------
a ---> a
using BasicReasoning
 mlIntro "H1".
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ a,
--------------------------------------
a
using BasicReasoning

  mlAssert ("H2" : a).
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
well_formed a
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf: well_formed a
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ a,
--------------------------------------
a
using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf: well_formed a
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ a,
"H2" ∶ a,
--------------------------------------
a
using BasicReasoning

  {
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
well_formed a wf_auto2. }
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf: well_formed a
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ a,
--------------------------------------
a
using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf: well_formed a
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ a,
"H2" ∶ a,
--------------------------------------
a
using BasicReasoning

  {
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf: well_formed a
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ a,
--------------------------------------
a
using BasicReasoning
 mlExact "H1". }
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf: well_formed a
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ a,
"H2" ∶ a,
--------------------------------------
a
using BasicReasoning

  mlAssert (a).
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf: well_formed a
well_formed a
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf, Hwf0: well_formed a
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ a,
"H2" ∶ a,
--------------------------------------
a
using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf, Hwf0: well_formed a
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ a,
"H2" ∶ a,
"0" ∶ a,
--------------------------------------
a
using BasicReasoning

  {
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf: well_formed a
well_formed a wf_auto2. }
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf, Hwf0: well_formed a
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ a,
"H2" ∶ a,
--------------------------------------
a
using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf, Hwf0: well_formed a
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ a,
"H2" ∶ a,
"0" ∶ a,
--------------------------------------
a
using BasicReasoning

  {
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf, Hwf0: well_formed a
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ a,
"H2" ∶ a,
--------------------------------------
a
using BasicReasoning
 mlExact "H1". }
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf, Hwf0: well_formed a
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ a,
"H2" ∶ a,
"0" ∶ a,
--------------------------------------
a
using BasicReasoning

  mlExact "H2".
Qed.

Ltac _getGoalProofInfo :=
  lazymatch goal with
  | |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm ?Ctx ?l ?g ?i)
    => i
  end.

Ltac _getGoalTheory :=
  lazymatch goal with
  | |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm ?Ctx ?l ?g ?i)
    => Ctx
  end.

Tactic Notation "mlAssert" "(" constr(name) ":" constr(t) ")" "using" "first" constr(n) :=
  _ensureProofMode;
  _failIfUsed name;
  lazymatch goal with
  | |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm ?Ctx ?l ?g ?i) =>
    let l1 := fresh "l1" in
    let l2 := fresh "l2" in
    let Heql1 := fresh "Heql1" in
    let Heql2 := fresh "Heql2" in
    remember (take n l) as l1 eqn:Heql1 in |-;
    remember (drop n l) as l2 eqn:Heql2 in |-;
    simpl in Heql1; simpl in Heql2;
    eapply cast_proof_ml_hyps;
    [(
      rewrite -[l](take_drop n);
      reflexivity
    )|];
    let Hwf := fresh "Hwf" in
    assert (Hwf : well_formed t);
    [idtac|
      let H := fresh "H" in
      assert (H : @mkMLGoal Sgm Ctx l1 t i) ;
      [
        (eapply cast_proof_ml_hyps; [(rewrite Heql1; reflexivity)|]);  clear l1 l2 Heql1 Heql2
      | apply (cast_proof_ml_hyps _ _ _ (f_equal patterns_of Heql1)) in H;
        eapply (@mlGoal_assert_generalized Sgm Ctx (take n l) (drop n l) name g t i Hwf H);
        rewrite [_ ++ _]/=; clear l1 l2 Heql1 Heql2 H] 
    ]
  end.

Tactic Notation "mlAssert" "(" constr(t) ")" "using" "first" constr(n)  :=
  _ensureProofMode;
  let hyps := _getHypNames in
  let name := eval cbv in (fresh hyps) in
  mlAssert (name : t) using first n.

Local Example ex_assert_using {Σ : Signature} Γ p q a b:
  well_formed a = true ->
  well_formed b = true ->
  well_formed p = true ->
  well_formed q = true ->
  Γ ⊢i a ---> p and q ---> b ---> ! ! q using BasicReasoning.
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
well_formed a = true
→ well_formed b = true
  → well_formed p = true
    → well_formed q = true
      → Γ ⊢i a ---> p and q ---> b ---> ! ! q
        using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
well_formed a = true
→ well_formed b = true
  → well_formed p = true
    → well_formed q = true
      → Γ ⊢i a ---> p and q ---> b ---> ! ! q
        using BasicReasoning
  intros wfa wfb wfp wfq.
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Γ ⊢i a ---> p and q ---> b ---> ! ! q
using BasicReasoning
  toMLGoal.
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
well_formed (a ---> p and q ---> b ---> ! ! q)
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Γ Ⱶ
a ---> p and q ---> b ---> ! ! q
using BasicReasoning

  {
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
well_formed (a ---> p and q ---> b ---> ! ! q) wf_auto2. }
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Γ Ⱶ
a ---> p and q ---> b ---> ! ! q
using BasicReasoning

  mlIntro "H0".
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Γ Ⱶ
"H0" ∶ a,
--------------------------------------
p and q ---> b ---> ! ! q
using BasicReasoning

  mlIntro "H1".
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ p and q,
--------------------------------------
b ---> ! ! q
using BasicReasoning

  mlIntro "H2".
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ p and q,
"H2" ∶ b,
--------------------------------------
! ! q
using BasicReasoning


  mlAssert ("H4" : p) using first 2.
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
l1: list named_hypothesis
Heql1: l1 = ("H0" ∶ a,
      "H1" ∶ p and q,
      )
l2: list named_hypothesis
Heql2: l2 = ("H2" ∶ b,
      )
well_formed p
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf: well_formed p
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ p and q,
--------------------------------------
p
using BasicReasoning
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf: well_formed p
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ p and q,
"H4" ∶ p,
"H2" ∶ b,
--------------------------------------
! ! q
using BasicReasoning

  {
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
l1: list named_hypothesis
Heql1: l1 = ("H0" ∶ a,
      "H1" ∶ p and q,
      )
l2: list named_hypothesis
Heql2: l2 = ("H2" ∶ b,
      )
well_formed p wf_auto2. }
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf: well_formed p
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ p and q,
--------------------------------------
p
using BasicReasoning
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf: well_formed p
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ p and q,
"H4" ∶ p,
"H2" ∶ b,
--------------------------------------
! ! q
using BasicReasoning

  {
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf: well_formed p
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ p and q,
--------------------------------------
p
using BasicReasoning
 admit. }
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf: well_formed p
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ p and q,
"H4" ∶ p,
"H2" ∶ b,
--------------------------------------
! ! q
using BasicReasoning


  mlAssert (p) using first 2.
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf: well_formed p
l1: list named_hypothesis
Heql1: l1 = ("H0" ∶ a,
      "H1" ∶ p and q,
      )
l2: list named_hypothesis
Heql2: l2 = ("H4" ∶ p,
      "H2" ∶ b,
      )
well_formed p
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf, Hwf0: well_formed p
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ p and q,
--------------------------------------
p
using BasicReasoning
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf, Hwf0: well_formed p
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ p and q,
"0" ∶ p,
"H4" ∶ p,
"H2" ∶ b,
--------------------------------------
! ! q
using BasicReasoning

  {
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf: well_formed p
l1: list named_hypothesis
Heql1: l1 = ("H0" ∶ a,
      "H1" ∶ p and q,
      )
l2: list named_hypothesis
Heql2: l2 = ("H4" ∶ p,
      "H2" ∶ b,
      )
well_formed p wf_auto2. }
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf, Hwf0: well_formed p
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ p and q,
--------------------------------------
p
using BasicReasoning
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf, Hwf0: well_formed p
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ p and q,
"0" ∶ p,
"H4" ∶ p,
"H2" ∶ b,
--------------------------------------
! ! q
using BasicReasoning

  {
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf, Hwf0: well_formed p
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ p and q,
--------------------------------------
p
using BasicReasoning
 admit. }
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf, Hwf0: well_formed p
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ p and q,
"0" ∶ p,
"H4" ∶ p,
"H2" ∶ b,
--------------------------------------
! ! q
using BasicReasoning

Abort.

Lemma P4i' {Σ : Signature} (Γ : Theory) (A : Pattern) :
  well_formed A →
  Γ ⊢i ((!A ---> A) ---> A) using BasicReasoning.
Σ: Signature
Γ: Theory
A: Pattern
well_formed A
→ Γ ⊢i (! A ---> A) ---> A using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
A: Pattern
well_formed A
→ Γ ⊢i (! A ---> A) ---> A using BasicReasoning
  intros wfA.
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
Γ ⊢i (! A ---> A) ---> A using BasicReasoning
  assert (H1: Γ ⊢i ((! A ---> ! ! A) ---> ! ! A) using BasicReasoning).
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
Γ ⊢i (! A ---> A) ---> A using BasicReasoning
  {
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning apply P4i.
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
well_formed (! A) wf_auto2. }
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
Γ ⊢i (! A ---> A) ---> A using BasicReasoning
  assert (H2: Γ ⊢i ((! A ---> A) ---> (! A ---> ! ! A)) using BasicReasoning).
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
Γ ⊢i (! A ---> A) ---> A using BasicReasoning
  {
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning eapply prf_weaken_conclusion_meta.
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
well_formed (! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
well_formed A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
well_formed (! ! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
Γ ⊢i A ---> ! ! A using BasicReasoning 
    4: apply not_not_intro.
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
well_formed (! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
well_formed A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
well_formed (! ! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
well_formed A
    all: wf_auto2.
  }
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
Γ ⊢i (! A ---> A) ---> A using BasicReasoning

  eapply prf_strenghten_premise_meta_meta.
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
well_formed ?A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
well_formed (! A ---> A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
well_formed A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
Γ ⊢i (! A ---> A) ---> ?A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
Γ ⊢i ?A ---> A using BasicReasoning 4: apply H2.
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
well_formed (! A ---> ! ! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
well_formed (! A ---> A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
well_formed A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
Γ ⊢i (! A ---> ! ! A) ---> A using BasicReasoning
  4: eapply prf_weaken_conclusion_meta_meta.
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
well_formed (! A ---> ! ! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
well_formed (! A ---> A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
well_formed A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
well_formed (! A ---> ! ! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
well_formed ?B
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
well_formed A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
Γ ⊢i ?B ---> A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
Γ ⊢i (! A ---> ! ! A) ---> ?B using BasicReasoning 7: apply not_not_elim.
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
well_formed (! A ---> ! ! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
well_formed (! A ---> A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
well_formed A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
well_formed (! A ---> ! ! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
well_formed (! ! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
well_formed A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
well_formed A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
  8: {
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning apply H1. }
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
well_formed (! A ---> ! ! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
well_formed (! A ---> A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
well_formed A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
well_formed (! A ---> ! ! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
well_formed (! ! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
well_formed A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A
using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A
using BasicReasoning
well_formed A
  all: wf_auto2.
Defined.

Lemma tofold {Σ : Signature} p:
  p = fold_right patt_imp p [].
Σ: Signature
p: Pattern
p = foldr patt_imp p []
Proof.
Σ: Signature
p: Pattern
p = foldr patt_imp p []
  reflexivity.
Defined.

Lemma consume {Σ : Signature} p q l:
  fold_right patt_imp (p ---> q) l = fold_right patt_imp q (l ++ [p]).
Σ: Signature
p, q: Pattern
l: list Pattern
foldr patt_imp (p ---> q) l =
foldr patt_imp q (l ++ [p])
Proof.
Σ: Signature
p, q: Pattern
l: list Pattern
foldr patt_imp (p ---> q) l =
foldr patt_imp q (l ++ [p])
  rewrite foldr_app.
Σ: Signature
p, q: Pattern
l: list Pattern
foldr patt_imp (p ---> q) l =
foldr patt_imp (foldr patt_imp q [p]) l reflexivity.
Defined.

Lemma prf_disj_elim {Σ : Signature} Γ p q r:
  well_formed p ->
  well_formed q ->
  well_formed r ->
  Γ ⊢i ((p ---> r) ---> (q ---> r) ---> (p or q) ---> r)
  using BasicReasoning.
Σ: Signature
Γ: Theory
p, q, r: Pattern
well_formed p
→ well_formed q
  → well_formed r
    → Γ
      ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r
      using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
p, q, r: Pattern
well_formed p
→ well_formed q
  → well_formed r
    → Γ
      ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r
      using BasicReasoning
  intros wfp wfq wfr.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r
using BasicReasoning
  pose proof (H1 := Constructive_dilemma Γ p r q r wfp wfr wfq wfr).
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H1: Γ
⊢i (p ---> r) --->
   (q ---> r) ---> p or q ---> r or r
using BasicReasoning
Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r
using BasicReasoning
  assert (Γ ⊢i ((r or r) ---> r) using BasicReasoning).
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H1: Γ
⊢i (p ---> r) --->
   (q ---> r) ---> p or q ---> r or r
using BasicReasoning
Γ ⊢i r or r ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H1: Γ
⊢i (p ---> r) --->
   (q ---> r) ---> p or q ---> r or r
using BasicReasoning
H: Γ ⊢i r or r ---> r using BasicReasoning
Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r
using BasicReasoning
  {
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H1: Γ
⊢i (p ---> r) --->
   (q ---> r) ---> p or q ---> r or r
using BasicReasoning
Γ ⊢i r or r ---> r using BasicReasoning unfold patt_or.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H1: Γ
⊢i (p ---> r) --->
   (q ---> r) ---> p or q ---> r or r
using BasicReasoning
Γ ⊢i (! r ---> r) ---> r using BasicReasoning apply P4i'.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H1: Γ
⊢i (p ---> r) --->
   (q ---> r) ---> p or q ---> r or r
using BasicReasoning
well_formed r wf_auto2. }
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H1: Γ
⊢i (p ---> r) --->
   (q ---> r) ---> p or q ---> r or r
using BasicReasoning
H: Γ ⊢i r or r ---> r using BasicReasoning
Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r
using BasicReasoning
  eapply cast_proof' in H1.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ ⊢i ?ψ using BasicReasoning
Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r
using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H1: Γ
⊢i (p ---> r) --->
   (q ---> r) ---> p or q ---> r or r
using BasicReasoning
H: Γ ⊢i r or r ---> r using BasicReasoning
?ψ =
((p ---> r) ---> (q ---> r) ---> p or q ---> r or r)
  2: {
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H1: Γ
⊢i (p ---> r) --->
   (q ---> r) ---> p or q ---> r or r
using BasicReasoning
H: Γ ⊢i r or r ---> r using BasicReasoning
?ψ =
((p ---> r) ---> (q ---> r) ---> p or q ---> r or r) rewrite -> tofold.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H1: Γ
⊢i (p ---> r) --->
   (q ---> r) ---> p or q ---> r or r
using BasicReasoning
H: Γ ⊢i r or r ---> r using BasicReasoning
?ψ =
foldr patt_imp
  ((p ---> r) ---> (q ---> r) ---> p or q ---> r or r)
  [] do 3 rewrite -> consume.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H1: Γ
⊢i (p ---> r) --->
   (q ---> r) ---> p or q ---> r or r
using BasicReasoning
H: Γ ⊢i r or r ---> r using BasicReasoning
?ψ =
foldr patt_imp (r or r)
  ((([] ++ [p ---> r]) ++ [q ---> r]) ++ [p or q]) reflexivity. }
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ
⊢i foldr patt_imp (r or r)
     ((([] ++ [p ---> r]) ++ [q ---> r]) ++
      [p or q]) using BasicReasoning
Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r
using BasicReasoning
  eapply prf_weaken_conclusion_iter_meta_meta in H1.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ
⊢i foldr patt_imp ?g'
     ((([] ++ [p ---> r]) ++ [q ---> r]) ++
      [p or q]) using BasicReasoning
Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r
using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ
⊢i foldr patt_imp (r or r)
     ((([] ++ [p ---> r]) ++ [q ---> r]) ++
      [p or q]) using BasicReasoning
Pattern.wf
  ((([] ++ [p ---> r]) ++ [q ---> r]) ++ [p or q])
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ
⊢i foldr patt_imp (r or r)
     ((([] ++ [p ---> r]) ++ [q ---> r]) ++
      [p or q]) using BasicReasoning
well_formed (r or r)
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ
⊢i foldr patt_imp (r or r)
     ((([] ++ [p ---> r]) ++ [q ---> r]) ++
      [p or q]) using BasicReasoning
well_formed ?g'
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ
⊢i foldr patt_imp (r or r)
     ((([] ++ [p ---> r]) ++ [q ---> r]) ++
      [p or q]) using BasicReasoning
Γ ⊢i r or r ---> ?g' using BasicReasoning 5: apply H.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ
⊢i foldr patt_imp r
     ((([] ++ [p ---> r]) ++ [q ---> r]) ++
      [p or q]) using BasicReasoning
Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r
using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ
⊢i foldr patt_imp (r or r)
     ((([] ++ [p ---> r]) ++ [q ---> r]) ++
      [p or q]) using BasicReasoning
Pattern.wf
  ((([] ++ [p ---> r]) ++ [q ---> r]) ++ [p or q])
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ
⊢i foldr patt_imp (r or r)
     ((([] ++ [p ---> r]) ++ [q ---> r]) ++
      [p or q]) using BasicReasoning
well_formed (r or r)
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ
⊢i foldr patt_imp (r or r)
     ((([] ++ [p ---> r]) ++ [q ---> r]) ++
      [p or q]) using BasicReasoning
well_formed r
  {
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ
⊢i foldr patt_imp r
     ((([] ++ [p ---> r]) ++ [q ---> r]) ++
      [p or q]) using BasicReasoning
Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r
using BasicReasoning apply H1. }
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ
⊢i foldr patt_imp (r or r)
     ((([] ++ [p ---> r]) ++ [q ---> r]) ++
      [p or q]) using BasicReasoning
Pattern.wf
  ((([] ++ [p ---> r]) ++ [q ---> r]) ++ [p or q])
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ
⊢i foldr patt_imp (r or r)
     ((([] ++ [p ---> r]) ++ [q ---> r]) ++
      [p or q]) using BasicReasoning
well_formed (r or r)
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ
⊢i foldr patt_imp (r or r)
     ((([] ++ [p ---> r]) ++ [q ---> r]) ++
      [p or q]) using BasicReasoning
well_formed r
  all: wf_auto2.
Defined.

Lemma prf_disj_elim_meta {Σ : Signature} Γ p q r i:
  well_formed p ->
  well_formed q ->
  well_formed r ->
  Γ ⊢i (p ---> r) using i ->
  Γ ⊢i ((q ---> r) ---> (p or q) ---> r) using i.
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
well_formed p
→ well_formed q
  → well_formed r
    → Γ ⊢i p ---> r using i
      → Γ ⊢i (q ---> r) ---> p or q ---> r using i
Proof.
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
well_formed p
→ well_formed q
  → well_formed r
    → Γ ⊢i p ---> r using i
      → Γ ⊢i (q ---> r) ---> p or q ---> r using i
  intros WFp WHq WFr H.
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
Γ ⊢i (q ---> r) ---> p or q ---> r using i
  eapply MP.
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
Γ ⊢i ?ϕ₁ ---> (q ---> r) ---> p or q ---> r using i apply H.
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r
using i useBasicReasoning.
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r
using BasicReasoning apply prf_disj_elim.
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
well_formed p
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
well_formed q
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
well_formed r
  all: wf_auto2.
Defined.

Lemma prf_disj_elim_meta_meta {Σ : Signature} Γ p q r i:
  well_formed p ->
  well_formed q ->
  well_formed r ->
  Γ ⊢i (p ---> r) using i ->
  Γ ⊢i (q ---> r) using i ->
  Γ ⊢i ((p or q) ---> r) using i.
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
well_formed p
→ well_formed q
  → well_formed r
    → Γ ⊢i p ---> r using i
      → Γ ⊢i q ---> r using i
        → Γ ⊢i p or q ---> r using i
Proof.
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
well_formed p
→ well_formed q
  → well_formed r
    → Γ ⊢i p ---> r using i
      → Γ ⊢i q ---> r using i
        → Γ ⊢i p or q ---> r using i
  intros WFp WHq WFr H H0.
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
Γ ⊢i p or q ---> r using i
  eapply MP.
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
Γ ⊢i ?ϕ₁ ---> p or q ---> r using i apply H0.
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
Γ ⊢i (q ---> r) ---> p or q ---> r using i apply prf_disj_elim_meta.
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
well_formed p
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
well_formed q
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
well_formed r
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
Γ ⊢i p ---> r using i 4: apply H.
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
well_formed p
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
well_formed q
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
well_formed r
  all: wf_auto2.
Defined.

Lemma prf_disj_elim_meta_meta_meta {Σ : Signature} Γ p q r i:
  well_formed p ->
  well_formed q ->
  well_formed r ->
  Γ ⊢i (p ---> r) using i ->
  Γ ⊢i (q ---> r) using i ->
  Γ ⊢i (p or q) using i ->
  Γ ⊢i r using i.
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
well_formed p
→ well_formed q
  → well_formed r
    → Γ ⊢i p ---> r using i
      → Γ ⊢i q ---> r using i
        → Γ ⊢i p or q using i → Γ ⊢i r using i
Proof.
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
well_formed p
→ well_formed q
  → well_formed r
    → Γ ⊢i p ---> r using i
      → Γ ⊢i q ---> r using i
        → Γ ⊢i p or q using i → Γ ⊢i r using i
  intros WFp WHq WFr H H0 H1.
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
H1: Γ ⊢i p or q using i
Γ ⊢i r using i
  eapply MP.
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
H1: Γ ⊢i p or q using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
H1: Γ ⊢i p or q using i
Γ ⊢i ?ϕ₁ ---> r using i apply H1.
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
H1: Γ ⊢i p or q using i
Γ ⊢i p or q ---> r using i
  apply prf_disj_elim_meta_meta.
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
H1: Γ ⊢i p or q using i
well_formed p
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
H1: Γ ⊢i p or q using i
well_formed q
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
H1: Γ ⊢i p or q using i
well_formed r
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
H1: Γ ⊢i p or q using i
Γ ⊢i p ---> r using i
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
H1: Γ ⊢i p or q using i
Γ ⊢i q ---> r using i
  all: assumption.
Defined.

Lemma prf_add_proved_to_assumptions {Σ : Signature} Γ l a g i:
  Pattern.wf l ->
  well_formed a ->
  well_formed g ->
  Γ ⊢i a using i->
  Γ ⊢i ((foldr patt_imp g (a::l)) ---> (foldr patt_imp g l)) using i.
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
Pattern.wf l
→ well_formed a
  → well_formed g
    → Γ ⊢i a using i
      → Γ
        ⊢i foldr patt_imp g (a :: l) --->
           foldr patt_imp g l using i
Proof.
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
Pattern.wf l
→ well_formed a
  → well_formed g
    → Γ ⊢i a using i
      → Γ
        ⊢i foldr patt_imp g (a :: l) --->
           foldr patt_imp g l using i
  intros wfl wfa wfg Ha.
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
wfl: Pattern.wf l
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
Γ ⊢i foldr patt_imp g (a :: l) ---> foldr patt_imp g l
using i
  induction l.
Σ: Signature
Γ: Theory
a, g: Pattern
i: ProofInfo
wfl: Pattern.wf []
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
Γ ⊢i foldr patt_imp g [a] ---> foldr patt_imp g []
using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfl: Pattern.wf (a0 :: l)
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp g (a :: l) ---> foldr patt_imp g l using i
Γ
⊢i foldr patt_imp g (a :: a0 :: l) --->
   foldr patt_imp g (a0 :: l) using i
  -
Σ: Signature
Γ: Theory
a, g: Pattern
i: ProofInfo
wfl: Pattern.wf []
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
Γ ⊢i foldr patt_imp g [a] ---> foldr patt_imp g []
using i simpl.
Σ: Signature
Γ: Theory
a, g: Pattern
i: ProofInfo
wfl: Pattern.wf []
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
Γ ⊢i (a ---> g) ---> g using i
    pose proof (modus_ponens Γ _ _ wfa wfg).
Σ: Signature
Γ: Theory
a, g: Pattern
i: ProofInfo
wfl: Pattern.wf []
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
H: Γ ⊢i a ---> (a ---> g) ---> g using BasicReasoning
Γ ⊢i (a ---> g) ---> g using i
    eapply MP.
Σ: Signature
Γ: Theory
a, g: Pattern
i: ProofInfo
wfl: Pattern.wf []
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
H: Γ ⊢i a ---> (a ---> g) ---> g using BasicReasoning
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
a, g: Pattern
i: ProofInfo
wfl: Pattern.wf []
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
H: Γ ⊢i a ---> (a ---> g) ---> g using BasicReasoning
Γ ⊢i ?ϕ₁ ---> (a ---> g) ---> g using i apply Ha.
Σ: Signature
Γ: Theory
a, g: Pattern
i: ProofInfo
wfl: Pattern.wf []
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
H: Γ ⊢i a ---> (a ---> g) ---> g using BasicReasoning
Γ ⊢i a ---> (a ---> g) ---> g using i useBasicReasoning.
Σ: Signature
Γ: Theory
a, g: Pattern
i: ProofInfo
wfl: Pattern.wf []
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
H: Γ ⊢i a ---> (a ---> g) ---> g using BasicReasoning
Γ ⊢i a ---> (a ---> g) ---> g using BasicReasoning apply H.
  -
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfl: Pattern.wf (a0 :: l)
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp g (a :: l) ---> foldr patt_imp g l using i
Γ
⊢i foldr patt_imp g (a :: a0 :: l) --->
   foldr patt_imp g (a0 :: l) using i pose proof (wfa0l := wfl).
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfl: Pattern.wf (a0 :: l)
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp g (a :: l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
Γ
⊢i foldr patt_imp g (a :: a0 :: l) --->
   foldr patt_imp g (a0 :: l) using i
    unfold Pattern.wf in wfl.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfl: foldr andb true (map well_formed (a0 :: l))
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp g (a :: l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
Γ
⊢i foldr patt_imp g (a :: a0 :: l) --->
   foldr patt_imp g (a0 :: l) using i simpl in wfl.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfl: well_formed a0 && foldr andb true (map well_formed l)
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp g (a :: l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
Γ
⊢i foldr patt_imp g (a :: a0 :: l) --->
   foldr patt_imp g (a0 :: l) using i apply andb_prop in wfl.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfl: well_formed a0 = true ∧ foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp g (a :: l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
Γ
⊢i foldr patt_imp g (a :: a0 :: l) --->
   foldr patt_imp g (a0 :: l) using i destruct wfl as [wfa0 wfl].
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Pattern.wf l
→ Γ
  ⊢i foldr patt_imp g (a :: l) --->
     foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
Γ
⊢i foldr patt_imp g (a :: a0 :: l) --->
   foldr patt_imp g (a0 :: l) using i
    specialize (IHl wfl).
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i foldr patt_imp g (a :: l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
Γ
⊢i foldr patt_imp g (a :: a0 :: l) --->
   foldr patt_imp g (a0 :: l) using i
    simpl in IHl.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
Γ
⊢i foldr patt_imp g (a :: a0 :: l) --->
   foldr patt_imp g (a0 :: l) using i simpl.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i
    (* < change a0 and a in the LHS > *)
    assert (H : Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> (a0 ---> a ---> foldr patt_imp g l) using BasicReasoning).
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i
    {
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning apply reorder; wf_auto2. }
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i

    eapply cast_proof'.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
((a ---> a0 ---> foldr patt_imp g l) --->
 a0 ---> foldr patt_imp g l) = ?ϕ
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
Γ ⊢i ?ϕ using i
    {
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
((a ---> a0 ---> foldr patt_imp g l) --->
 a0 ---> foldr patt_imp g l) = ?ϕ rewrite -> tofold.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
((a ---> a0 ---> foldr patt_imp g l) --->
 a0 ---> foldr patt_imp g l) = foldr patt_imp ?ϕ [] rewrite -> consume.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
((a ---> a0 ---> foldr patt_imp g l) --->
 a0 ---> foldr patt_imp g l) =
foldr patt_imp ?q ([] ++ [?p]) reflexivity. }
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i
    pose proof (H0 := prf_strenghten_premise_iter_meta_meta Γ [] []).
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
H0: ∀ (h h' g : Pattern) (i : ProofInfo),
  Pattern.wf []
  → Pattern.wf []
    → well_formed h
      → well_formed h'
        → well_formed g
          → Γ ⊢i h' ---> h using i
            → Γ ⊢i foldr patt_imp g ([] ++ [h])
              using i
              → Γ
                ⊢i foldr patt_imp g ([] ++ [h'])
                using i
Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i
    simpl in H0.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
H0: ∀ (h h' g : Pattern) (i : ProofInfo),
  Pattern.wf []
  → Pattern.wf []
    → well_formed h
      → well_formed h'
        → well_formed g
          → Γ ⊢i h' ---> h using i
            → Γ ⊢i h ---> g using i
              → Γ ⊢i h' ---> g using i
Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i simpl.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
H0: ∀ (h h' g : Pattern) (i : ProofInfo),
  Pattern.wf []
  → Pattern.wf []
    → well_formed h
      → well_formed h'
        → well_formed g
          → Γ ⊢i h' ---> h using i
            → Γ ⊢i h ---> g using i
              → Γ ⊢i h' ---> g using i
Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i
    specialize (H0 (a0 ---> a ---> foldr patt_imp g l) (a ---> a0 ---> foldr patt_imp g l)).
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
H0: ∀ (g0 : Pattern) (i : ProofInfo),
  Pattern.wf []
  → Pattern.wf []
    → well_formed
        (a0 ---> a ---> foldr patt_imp g l)
      → well_formed
          (a ---> a0 ---> foldr patt_imp g l)
        → well_formed g0
          → Γ
            ⊢i (a ---> a0 ---> foldr patt_imp g l) --->
               a0 ---> a ---> foldr patt_imp g l
            using i
            → Γ
              ⊢i (a0 --->
                  a ---> foldr patt_imp g l) --->
                 g0 using i
              → Γ
                ⊢i (a --->
                    a0 ---> foldr patt_imp g l) --->
                   g0 using i
Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i
    specialize (H0 (a0 ---> foldr patt_imp g l)).
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
H0: ∀ i : ProofInfo,
  Pattern.wf []
  → Pattern.wf []
    → well_formed
        (a0 ---> a ---> foldr patt_imp g l)
      → well_formed
          (a ---> a0 ---> foldr patt_imp g l)
        → well_formed
            (a0 ---> foldr patt_imp g l)
          → Γ
            ⊢i (a ---> a0 ---> foldr patt_imp g l) --->
               a0 ---> a ---> foldr patt_imp g l
            using i
            → Γ
              ⊢i (a0 --->
                  a ---> foldr patt_imp g l) --->
                 a0 ---> foldr patt_imp g l
              using i
              → Γ
                ⊢i (a --->
                    a0 ---> foldr patt_imp g l) --->
                   a0 ---> foldr patt_imp g l
                using i
Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i simpl in H0.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
H0: ∀ i : ProofInfo,
  Pattern.wf []
  → Pattern.wf []
    → well_formed
        (a0 ---> a ---> foldr patt_imp g l)
      → well_formed
          (a ---> a0 ---> foldr patt_imp g l)
        → well_formed
            (a0 ---> foldr patt_imp g l)
          → Γ
            ⊢i (a ---> a0 ---> foldr patt_imp g l) --->
               a0 ---> a ---> foldr patt_imp g l
            using i
            → Γ
              ⊢i (a0 --->
                  a ---> foldr patt_imp g l) --->
                 a0 ---> foldr patt_imp g l
              using i
              → Γ
                ⊢i (a --->
                    a0 ---> foldr patt_imp g l) --->
                   a0 ---> foldr patt_imp g l
                using i
Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i simpl.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
H0: ∀ i : ProofInfo,
  Pattern.wf []
  → Pattern.wf []
    → well_formed
        (a0 ---> a ---> foldr patt_imp g l)
      → well_formed
          (a ---> a0 ---> foldr patt_imp g l)
        → well_formed
            (a0 ---> foldr patt_imp g l)
          → Γ
            ⊢i (a ---> a0 ---> foldr patt_imp g l) --->
               a0 ---> a ---> foldr patt_imp g l
            using i
            → Γ
              ⊢i (a0 --->
                  a ---> foldr patt_imp g l) --->
                 a0 ---> foldr patt_imp g l
              using i
              → Γ
                ⊢i (a --->
                    a0 ---> foldr patt_imp g l) --->
                   a0 ---> foldr patt_imp g l
                using i
Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i
    simpl.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
H0: ∀ i : ProofInfo,
  Pattern.wf []
  → Pattern.wf []
    → well_formed
        (a0 ---> a ---> foldr patt_imp g l)
      → well_formed
          (a ---> a0 ---> foldr patt_imp g l)
        → well_formed
            (a0 ---> foldr patt_imp g l)
          → Γ
            ⊢i (a ---> a0 ---> foldr patt_imp g l) --->
               a0 ---> a ---> foldr patt_imp g l
            using i
            → Γ
              ⊢i (a0 --->
                  a ---> foldr patt_imp g l) --->
                 a0 ---> foldr patt_imp g l
              using i
              → Γ
                ⊢i (a --->
                    a0 ---> foldr patt_imp g l) --->
                   a0 ---> foldr patt_imp g l
                using i
Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i apply H0.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
H0: ∀ i : ProofInfo,
  Pattern.wf []
  → Pattern.wf []
    → well_formed
        (a0 ---> a ---> foldr patt_imp g l)
      → well_formed
          (a ---> a0 ---> foldr patt_imp g l)
        → well_formed
            (a0 ---> foldr patt_imp g l)
          → Γ
            ⊢i (a ---> a0 ---> foldr patt_imp g l) --->
               a0 ---> a ---> foldr patt_imp g l
            using i
            → Γ
              ⊢i (a0 --->
                  a ---> foldr patt_imp g l) --->
                 a0 ---> foldr patt_imp g l
              using i
              → Γ
                ⊢i (a --->
                    a0 ---> foldr patt_imp g l) --->
                   a0 ---> foldr patt_imp g l
                using i
Pattern.wf []
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
H0: ∀ i : ProofInfo,
  Pattern.wf []
  → Pattern.wf []
    → well_formed
        (a0 ---> a ---> foldr patt_imp g l)
      → well_formed
          (a ---> a0 ---> foldr patt_imp g l)
        → well_formed
            (a0 ---> foldr patt_imp g l)
          → Γ
            ⊢i (a ---> a0 ---> foldr patt_imp g l) --->
               a0 ---> a ---> foldr patt_imp g l
            using i
            → Γ
              ⊢i (a0 --->
                  a ---> foldr patt_imp g l) --->
                 a0 ---> foldr patt_imp g l
              using i
              → Γ
                ⊢i (a --->
                    a0 ---> foldr patt_imp g l) --->
                   a0 ---> foldr patt_imp g l
                using i
Pattern.wf []
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
H0: ∀ i : ProofInfo,
  Pattern.wf []
  → Pattern.wf []
    → well_formed
        (a0 ---> a ---> foldr patt_imp g l)
      → well_formed
          (a ---> a0 ---> foldr patt_imp g l)
        → well_formed
            (a0 ---> foldr patt_imp g l)
          → Γ
            ⊢i (a ---> a0 ---> foldr patt_imp g l) --->
               a0 ---> a ---> foldr patt_imp g l
            using i
            → Γ
              ⊢i (a0 --->
                  a ---> foldr patt_imp g l) --->
                 a0 ---> foldr patt_imp g l
              using i
              → Γ
                ⊢i (a --->
                    a0 ---> foldr patt_imp g l) --->
                   a0 ---> foldr patt_imp g l
                using i
well_formed (a0 ---> a ---> foldr patt_imp g l)
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
H0: ∀ i : ProofInfo,
  Pattern.wf []
  → Pattern.wf []
    → well_formed
        (a0 ---> a ---> foldr patt_imp g l)
      → well_formed
          (a ---> a0 ---> foldr patt_imp g l)
        → well_formed
            (a0 ---> foldr patt_imp g l)
          → Γ
            ⊢i (a ---> a0 ---> foldr patt_imp g l) --->
               a0 ---> a ---> foldr patt_imp g l
            using i
            → Γ
              ⊢i (a0 --->
                  a ---> foldr patt_imp g l) --->
                 a0 ---> foldr patt_imp g l
              using i
              → Γ
                ⊢i (a --->
                    a0 ---> foldr patt_imp g l) --->
                   a0 ---> foldr patt_imp g l
                using i
well_formed (a ---> a0 ---> foldr patt_imp g l)
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
H0: ∀ i : ProofInfo,
  Pattern.wf []
  → Pattern.wf []
    → well_formed
        (a0 ---> a ---> foldr patt_imp g l)
      → well_formed
          (a ---> a0 ---> foldr patt_imp g l)
        → well_formed
            (a0 ---> foldr patt_imp g l)
          → Γ
            ⊢i (a ---> a0 ---> foldr patt_imp g l) --->
               a0 ---> a ---> foldr patt_imp g l
            using i
            → Γ
              ⊢i (a0 --->
                  a ---> foldr patt_imp g l) --->
                 a0 ---> foldr patt_imp g l
              using i
              → Γ
                ⊢i (a --->
                    a0 ---> foldr patt_imp g l) --->
                   a0 ---> foldr patt_imp g l
                using i
well_formed (a0 ---> foldr patt_imp g l)
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
H0: ∀ i : ProofInfo,
  Pattern.wf []
  → Pattern.wf []
    → well_formed
        (a0 ---> a ---> foldr patt_imp g l)
      → well_formed
          (a ---> a0 ---> foldr patt_imp g l)
        → well_formed
            (a0 ---> foldr patt_imp g l)
          → Γ
            ⊢i (a ---> a0 ---> foldr patt_imp g l) --->
               a0 ---> a ---> foldr patt_imp g l
            using i
            → Γ
              ⊢i (a0 --->
                  a ---> foldr patt_imp g l) --->
                 a0 ---> foldr patt_imp g l
              using i
              → Γ
                ⊢i (a --->
                    a0 ---> foldr patt_imp g l) --->
                   a0 ---> foldr patt_imp g l
                using i
Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
H0: ∀ i : ProofInfo,
  Pattern.wf []
  → Pattern.wf []
    → well_formed
        (a0 ---> a ---> foldr patt_imp g l)
      → well_formed
          (a ---> a0 ---> foldr patt_imp g l)
        → well_formed
            (a0 ---> foldr patt_imp g l)
          → Γ
            ⊢i (a ---> a0 ---> foldr patt_imp g l) --->
               a0 ---> a ---> foldr patt_imp g l
            using i
            → Γ
              ⊢i (a0 --->
                  a ---> foldr patt_imp g l) --->
                 a0 ---> foldr patt_imp g l
              using i
              → Γ
                ⊢i (a --->
                    a0 ---> foldr patt_imp g l) --->
                   a0 ---> foldr patt_imp g l
                using i
Γ
⊢i (a0 ---> a ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i all: try_wfauto2.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
H0: ∀ i : ProofInfo,
  Pattern.wf []
  → Pattern.wf []
    → well_formed
        (a0 ---> a ---> foldr patt_imp g l)
      → well_formed
          (a ---> a0 ---> foldr patt_imp g l)
        → well_formed
            (a0 ---> foldr patt_imp g l)
          → Γ
            ⊢i (a ---> a0 ---> foldr patt_imp g l) --->
               a0 ---> a ---> foldr patt_imp g l
            using i
            → Γ
              ⊢i (a0 --->
                  a ---> foldr patt_imp g l) --->
                 a0 ---> foldr patt_imp g l
              using i
              → Γ
                ⊢i (a --->
                    a0 ---> foldr patt_imp g l) --->
                   a0 ---> foldr patt_imp g l
                using i
Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
H0: ∀ i : ProofInfo,
  Pattern.wf []
  → Pattern.wf []
    → well_formed
        (a0 ---> a ---> foldr patt_imp g l)
      → well_formed
          (a ---> a0 ---> foldr patt_imp g l)
        → well_formed
            (a0 ---> foldr patt_imp g l)
          → Γ
            ⊢i (a ---> a0 ---> foldr patt_imp g l) --->
               a0 ---> a ---> foldr patt_imp g l
            using i
            → Γ
              ⊢i (a0 --->
                  a ---> foldr patt_imp g l) --->
                 a0 ---> foldr patt_imp g l
              using i
              → Γ
                ⊢i (a --->
                    a0 ---> foldr patt_imp g l) --->
                   a0 ---> foldr patt_imp g l
                using i
Γ
⊢i (a0 ---> a ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i
    {
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
H0: ∀ i : ProofInfo,
  Pattern.wf []
  → Pattern.wf []
    → well_formed
        (a0 ---> a ---> foldr patt_imp g l)
      → well_formed
          (a ---> a0 ---> foldr patt_imp g l)
        → well_formed
            (a0 ---> foldr patt_imp g l)
          → Γ
            ⊢i (a ---> a0 ---> foldr patt_imp g l) --->
               a0 ---> a ---> foldr patt_imp g l
            using i
            → Γ
              ⊢i (a0 --->
                  a ---> foldr patt_imp g l) --->
                 a0 ---> foldr patt_imp g l
              using i
              → Γ
                ⊢i (a --->
                    a0 ---> foldr patt_imp g l) --->
                   a0 ---> foldr patt_imp g l
                using i
Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l using i useBasicReasoning.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
H0: ∀ i : ProofInfo,
  Pattern.wf []
  → Pattern.wf []
    → well_formed
        (a0 ---> a ---> foldr patt_imp g l)
      → well_formed
          (a ---> a0 ---> foldr patt_imp g l)
        → well_formed
            (a0 ---> foldr patt_imp g l)
          → Γ
            ⊢i (a ---> a0 ---> foldr patt_imp g l) --->
               a0 ---> a ---> foldr patt_imp g l
            using i
            → Γ
              ⊢i (a0 --->
                  a ---> foldr patt_imp g l) --->
                 a0 ---> foldr patt_imp g l
              using i
              → Γ
                ⊢i (a --->
                    a0 ---> foldr patt_imp g l) --->
                   a0 ---> foldr patt_imp g l
                using i
Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning apply H. }
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> a ---> foldr patt_imp g l
using BasicReasoning
H0: ∀ i : ProofInfo,
  Pattern.wf []
  → Pattern.wf []
    → well_formed
        (a0 ---> a ---> foldr patt_imp g l)
      → well_formed
          (a ---> a0 ---> foldr patt_imp g l)
        → well_formed
            (a0 ---> foldr patt_imp g l)
          → Γ
            ⊢i (a ---> a0 ---> foldr patt_imp g l) --->
               a0 ---> a ---> foldr patt_imp g l
            using i
            → Γ
              ⊢i (a0 --->
                  a ---> foldr patt_imp g l) --->
                 a0 ---> foldr patt_imp g l
              using i
              → Γ
                ⊢i (a --->
                    a0 ---> foldr patt_imp g l) --->
                   a0 ---> foldr patt_imp g l
                using i
Γ
⊢i (a0 ---> a ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i
    clear H0 H.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
Γ
⊢i (a0 ---> a ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i
    (* </change a0 and a > *)
    assert (Γ ⊢i ((a ---> a0 ---> foldr patt_imp g l) ---> (a0 ---> foldr patt_imp g l)) using i).
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i
Γ
⊢i (a0 ---> a ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i
    {
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i eapply MP.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
Γ
⊢i ?ϕ₁ --->
   (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i 2: {
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
Γ
⊢i ?ϕ₁ --->
   (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i useBasicReasoning.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
Γ
⊢i ?ϕ₁ --->
   (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using BasicReasoning apply modus_ponens; wf_auto2. }
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
Γ ⊢i a using i apply Ha. }
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i
Γ
⊢i (a0 ---> a ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i

    eapply prf_strenghten_premise_meta_meta.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i
well_formed ?A
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i
well_formed (a0 ---> a ---> foldr patt_imp g l)
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i
well_formed (a0 ---> foldr patt_imp g l)
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i
Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> ?A
using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i
Γ ⊢i ?A ---> a0 ---> foldr patt_imp g l using i 5: apply H.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i
well_formed (a ---> a0 ---> foldr patt_imp g l)
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i
well_formed (a0 ---> a ---> foldr patt_imp g l)
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i
well_formed (a0 ---> foldr patt_imp g l)
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i
Γ
⊢i (a0 ---> a ---> foldr patt_imp g l) --->
   a ---> a0 ---> foldr patt_imp g l using i all: try_wfauto2.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i
Γ
⊢i (a0 ---> a ---> foldr patt_imp g l) --->
   a ---> a0 ---> foldr patt_imp g l using i
    useBasicReasoning.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ
⊢i (a ---> foldr patt_imp g l) --->
   foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ
⊢i (a ---> a0 ---> foldr patt_imp g l) --->
   a0 ---> foldr patt_imp g l using i
Γ
⊢i (a0 ---> a ---> foldr patt_imp g l) --->
   a ---> a0 ---> foldr patt_imp g l
using BasicReasoning
    apply reorder; wf_auto2.
Defined.

Lemma prf_add_proved_to_assumptions_meta {Σ : Signature} Γ l a g i:
  Pattern.wf l ->
  well_formed a ->
  well_formed g ->
  Γ ⊢i a using i ->
  Γ ⊢i (foldr patt_imp g (a::l)) using i ->
  Γ ⊢i (foldr patt_imp g l) using i.
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
Pattern.wf l
→ well_formed a
  → well_formed g
    → Γ ⊢i a using i
      → Γ ⊢i foldr patt_imp g (a :: l) using i
        → Γ ⊢i foldr patt_imp g l using i
Proof.
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
Pattern.wf l
→ well_formed a
  → well_formed g
    → Γ ⊢i a using i
      → Γ ⊢i foldr patt_imp g (a :: l) using i
        → Γ ⊢i foldr patt_imp g l using i
  intros WFl WFa WFg H H0.
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFa: well_formed a
WFg: well_formed g
H: Γ ⊢i a using i
H0: Γ ⊢i foldr patt_imp g (a :: l) using i
Γ ⊢i foldr patt_imp g l using i
  eapply MP.
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFa: well_formed a
WFg: well_formed g
H: Γ ⊢i a using i
H0: Γ ⊢i foldr patt_imp g (a :: l) using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFa: well_formed a
WFg: well_formed g
H: Γ ⊢i a using i
H0: Γ ⊢i foldr patt_imp g (a :: l) using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp g l using i
  apply H0.
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFa: well_formed a
WFg: well_formed g
H: Γ ⊢i a using i
H0: Γ ⊢i foldr patt_imp g (a :: l) using i
Γ ⊢i foldr patt_imp g (a :: l) ---> foldr patt_imp g l
using i
  eapply prf_add_proved_to_assumptions.
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFa: well_formed a
WFg: well_formed g
H: Γ ⊢i a using i
H0: Γ ⊢i foldr patt_imp g (a :: l) using i
Pattern.wf l
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFa: well_formed a
WFg: well_formed g
H: Γ ⊢i a using i
H0: Γ ⊢i foldr patt_imp g (a :: l) using i
well_formed a
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFa: well_formed a
WFg: well_formed g
H: Γ ⊢i a using i
H0: Γ ⊢i foldr patt_imp g (a :: l) using i
well_formed g
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFa: well_formed a
WFg: well_formed g
H: Γ ⊢i a using i
H0: Γ ⊢i foldr patt_imp g (a :: l) using i
Γ ⊢i a using i
  4: apply H.
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFa: well_formed a
WFg: well_formed g
H: Γ ⊢i a using i
H0: Γ ⊢i foldr patt_imp g (a :: l) using i
Pattern.wf l
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFa: well_formed a
WFg: well_formed g
H: Γ ⊢i a using i
H0: Γ ⊢i foldr patt_imp g (a :: l) using i
well_formed a
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFa: well_formed a
WFg: well_formed g
H: Γ ⊢i a using i
H0: Γ ⊢i foldr patt_imp g (a :: l) using i
well_formed g
  all: wf_auto2.
Defined.

Lemma MLGoal_add {Σ : Signature} Γ l name g h i:
  Γ ⊢i h using i ->
  mkMLGoal Σ Γ (mkNH _ name h::l) g i ->
  mkMLGoal Σ Γ l g i.
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
Γ ⊢i h using i
→ Γ Ⱶ
  (name ∶ h) :: l--------------------------------------
  g
  using i
  
  → Γ Ⱶ
  l--------------------------------------
  g
  using i
  
Proof.
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
Γ ⊢i h using i
→ Γ Ⱶ
  (name ∶ h) :: l--------------------------------------
  g
  using i
  
  → Γ Ⱶ
  l--------------------------------------
  g
  using i
  
  intros H H0.
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: Γ Ⱶ
(name ∶ h) :: l--------------------------------------
g
using i

Γ Ⱶ
l--------------------------------------
g
using i

  unfold of_MLGoal in *.
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed
  (mlConclusion
     (Γ Ⱶ
      (name ∶ h) :: l--------------------------------------
      g
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           (name ∶ h) :: l--------------------------------------
           g
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       (name ∶ h) :: l--------------------------------------
       g
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             (name ∶ h) :: l--------------------------------------
             g
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                (name ∶ h) :: l--------------------------------------
                g
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             (name ∶ h) :: l--------------------------------------
             g
             using i
             )
well_formed
  (mlConclusion
     (Γ Ⱶ
      l--------------------------------------
      g
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l--------------------------------------
           g
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       l--------------------------------------
       g
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l--------------------------------------
             g
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l--------------------------------------
                g
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             l--------------------------------------
             g
             using i
             ) simpl in *.
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g
→ Pattern.wf (h :: patterns_of l)
  → Γ ⊢i h ---> foldr patt_imp g (patterns_of l)
    using i
well_formed g
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp g (patterns_of l) using i
  intros wfg wfl.
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g
→ Pattern.wf (h :: patterns_of l)
  → Γ ⊢i h ---> foldr patt_imp g (patterns_of l)
    using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp g (patterns_of l) using i
  apply prf_add_proved_to_assumptions_meta with (a := h).
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g
→ Pattern.wf (h :: patterns_of l)
  → Γ ⊢i h ---> foldr patt_imp g (patterns_of l)
    using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g
→ Pattern.wf (h :: patterns_of l)
  → Γ ⊢i h ---> foldr patt_imp g (patterns_of l)
    using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed h
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g
→ Pattern.wf (h :: patterns_of l)
  → Γ ⊢i h ---> foldr patt_imp g (patterns_of l)
    using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed g
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g
→ Pattern.wf (h :: patterns_of l)
  → Γ ⊢i h ---> foldr patt_imp g (patterns_of l)
    using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Γ ⊢i h using i
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g
→ Pattern.wf (h :: patterns_of l)
  → Γ ⊢i h ---> foldr patt_imp g (patterns_of l)
    using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp g (h :: patterns_of l) using i
  5: apply H0.
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g
→ Pattern.wf (h :: patterns_of l)
  → Γ ⊢i h ---> foldr patt_imp g (patterns_of l)
    using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g
→ Pattern.wf (h :: patterns_of l)
  → Γ ⊢i h ---> foldr patt_imp g (patterns_of l)
    using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed h
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g
→ Pattern.wf (h :: patterns_of l)
  → Γ ⊢i h ---> foldr patt_imp g (patterns_of l)
    using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed g
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g
→ Pattern.wf (h :: patterns_of l)
  → Γ ⊢i h ---> foldr patt_imp g (patterns_of l)
    using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Γ ⊢i h using i
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g
→ Pattern.wf (h :: patterns_of l)
  → Γ ⊢i h ---> foldr patt_imp g (patterns_of l)
    using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed g
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g
→ Pattern.wf (h :: patterns_of l)
  → Γ ⊢i h ---> foldr patt_imp g (patterns_of l)
    using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Pattern.wf (h :: patterns_of l)
  all: try assumption.
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g
→ Pattern.wf (h :: patterns_of l)
  → Γ ⊢i h ---> foldr patt_imp g (patterns_of l)
    using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed h
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g
→ Pattern.wf (h :: patterns_of l)
  → Γ ⊢i h ---> foldr patt_imp g (patterns_of l)
    using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Pattern.wf (h :: patterns_of l)
  {
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g
→ Pattern.wf (h :: patterns_of l)
  → Γ ⊢i h ---> foldr patt_imp g (patterns_of l)
    using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed h abstract (pose (tmp := proj1_sig H); apply proved_impl_wf in tmp; exact tmp). }
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g
→ Pattern.wf (h :: patterns_of l)
  → Γ ⊢i h ---> foldr patt_imp g (patterns_of l)
    using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Pattern.wf (h :: patterns_of l)
  {
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g
→ Pattern.wf (h :: patterns_of l)
  → Γ ⊢i h ---> foldr patt_imp g (patterns_of l)
    using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Pattern.wf (h :: patterns_of l) abstract (
        unfold Pattern.wf;
        simpl;
        pose (tmp := proj1_sig H);
        apply proved_impl_wf in tmp;
        rewrite tmp;
        simpl;
        exact wfl
    ).
  }
Defined.

Tactic Notation "mlAdd" constr(n) "as" constr(name') :=
  _ensureProofMode;
  _failIfUsed name';
  match goal with
  | |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm ?Ctx ?l ?g ?i) =>
    apply (@MLGoal_add Sgm Ctx l name' g _ i n)
  end.

Tactic Notation "mlAdd" constr(n) :=
  _ensureProofMode;
  let hyps := _getHypNames in
  let name := eval cbv in (fresh hyps) in
  mlAdd n as name.

Local Example ex_mlAdd {Σ : Signature} Γ l g h i:
  Pattern.wf l ->
  well_formed g ->
  well_formed h ->
  Γ ⊢i (h ---> g) using i ->
  Γ ⊢i h using i ->
  Γ ⊢i g using i.
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
Pattern.wf l
→ well_formed g
  → well_formed h
    → Γ ⊢i h ---> g using i
      → Γ ⊢i h using i → Γ ⊢i g using i
Proof.
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
Pattern.wf l
→ well_formed g
  → well_formed h
    → Γ ⊢i h ---> g using i
      → Γ ⊢i h using i → Γ ⊢i g using i
  intros WFl WFg WFh H H0.
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WFh: well_formed h
H: Γ ⊢i h ---> g using i
H0: Γ ⊢i h using i
Γ ⊢i g using i
  mlAdd H0 as "H0".
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WFh: well_formed h
H: Γ ⊢i h ---> g using i
H0: Γ ⊢i h using i
Γ Ⱶ
"H0" ∶ h,
--------------------------------------
g
using i

  mlAdd H.
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WFh: well_formed h
H: Γ ⊢i h ---> g using i
H0: Γ ⊢i h using i
Γ Ⱶ
"0" ∶ h ---> g,
"H0" ∶ h,
--------------------------------------
g
using i

  mlApply "0".
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WFh: well_formed h
H: Γ ⊢i h ---> g using i
H0: Γ ⊢i h using i
Γ Ⱶ
"0" ∶ h ---> g,
"H0" ∶ h,
--------------------------------------
h
using i

  mlExact "H0".
Defined.


Lemma prf_clear_hyp {Σ : Signature} Γ l1 l2 g h:
  Pattern.wf l1 ->
  Pattern.wf l2 ->
  well_formed g ->
  well_formed h ->
  Γ ⊢i (foldr patt_imp g (l1 ++ l2)) ---> (foldr patt_imp g (l1 ++ [h] ++ l2))
  using BasicReasoning.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
Pattern.wf l1
→ Pattern.wf l2
  → well_formed g
    → well_formed h
      → Γ
        ⊢i foldr patt_imp g (l1 ++ l2) --->
           foldr patt_imp g (l1 ++ [h] ++ l2)
        using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
Pattern.wf l1
→ Pattern.wf l2
  → well_formed g
    → well_formed h
      → Γ
        ⊢i foldr patt_imp g (l1 ++ l2) --->
           foldr patt_imp g (l1 ++ [h] ++ l2)
        using BasicReasoning
  intros wfl1 wfl2 wfg wfh.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
wfl1: Pattern.wf l1
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
Γ
⊢i foldr patt_imp g (l1 ++ l2) --->
   foldr patt_imp g (l1 ++ [h] ++ l2)
using BasicReasoning
  induction l1; simpl.
Σ: Signature
Γ: Theory
l2: list Pattern
g, h: Pattern
wfl1: Pattern.wf []
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
Γ
⊢i foldr patt_imp g l2 ---> h ---> foldr patt_imp g l2
using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfl1: Pattern.wf (a :: l1)
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Pattern.wf l1
→ Γ
  ⊢i foldr patt_imp g (l1 ++ l2) --->
     foldr patt_imp g (l1 ++ [h] ++ l2)
  using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp g (l1 ++ l2)) --->
   a ---> foldr patt_imp g (l1 ++ h :: l2)
using BasicReasoning
  -
Σ: Signature
Γ: Theory
l2: list Pattern
g, h: Pattern
wfl1: Pattern.wf []
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
Γ
⊢i foldr patt_imp g l2 ---> h ---> foldr patt_imp g l2
using BasicReasoning apply P1; wf_auto2.
  -
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfl1: Pattern.wf (a :: l1)
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Pattern.wf l1
→ Γ
  ⊢i foldr patt_imp g (l1 ++ l2) --->
     foldr patt_imp g (l1 ++ [h] ++ l2)
  using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp g (l1 ++ l2)) --->
   a ---> foldr patt_imp g (l1 ++ h :: l2)
using BasicReasoning unfold Pattern.wf in wfl1.
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfl1: foldr andb true (map well_formed (a :: l1))
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Pattern.wf l1
→ Γ
  ⊢i foldr patt_imp g (l1 ++ l2) --->
     foldr patt_imp g (l1 ++ [h] ++ l2)
  using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp g (l1 ++ l2)) --->
   a ---> foldr patt_imp g (l1 ++ h :: l2)
using BasicReasoning simpl in wfl1.
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfl1: well_formed a &&
foldr andb true (map well_formed l1)
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Pattern.wf l1
→ Γ
  ⊢i foldr patt_imp g (l1 ++ l2) --->
     foldr patt_imp g (l1 ++ [h] ++ l2)
  using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp g (l1 ++ l2)) --->
   a ---> foldr patt_imp g (l1 ++ h :: l2)
using BasicReasoning apply andb_prop in wfl1.
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfl1: well_formed a = true
∧ foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Pattern.wf l1
→ Γ
  ⊢i foldr patt_imp g (l1 ++ l2) --->
     foldr patt_imp g (l1 ++ [h] ++ l2)
  using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp g (l1 ++ l2)) --->
   a ---> foldr patt_imp g (l1 ++ h :: l2)
using BasicReasoning destruct wfl1 as [wfa wfl1].
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Pattern.wf l1
→ Γ
  ⊢i foldr patt_imp g (l1 ++ l2) --->
     foldr patt_imp g (l1 ++ [h] ++ l2)
  using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp g (l1 ++ l2)) --->
   a ---> foldr patt_imp g (l1 ++ h :: l2)
using BasicReasoning
    specialize (IHl1 wfl1).
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp g (l1 ++ l2) --->
   foldr patt_imp g (l1 ++ [h] ++ l2)
using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp g (l1 ++ l2)) --->
   a ---> foldr patt_imp g (l1 ++ h :: l2)
using BasicReasoning

    assert (H1: Γ ⊢i a ---> foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning).
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp g (l1 ++ l2) --->
   foldr patt_imp g (l1 ++ [h] ++ l2)
using BasicReasoning
Γ
⊢i a --->
   foldr patt_imp g (l1 ++ l2) --->
   foldr patt_imp g (l1 ++ [h] ++ l2)
using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp g (l1 ++ l2) --->
   foldr patt_imp g (l1 ++ [h] ++ l2)
using BasicReasoning
H1: Γ
⊢i a --->
   foldr patt_imp g (l1 ++ l2) --->
   foldr patt_imp g (l1 ++ [h] ++ l2)
using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp g (l1 ++ l2)) --->
   a ---> foldr patt_imp g (l1 ++ h :: l2)
using BasicReasoning
    {
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp g (l1 ++ l2) --->
   foldr patt_imp g (l1 ++ [h] ++ l2)
using BasicReasoning
Γ
⊢i a --->
   foldr patt_imp g (l1 ++ l2) --->
   foldr patt_imp g (l1 ++ [h] ++ l2)
using BasicReasoning
      toMLGoal.
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp g (l1 ++ l2) --->
   foldr patt_imp g (l1 ++ [h] ++ l2)
using BasicReasoning
well_formed
  (a --->
   foldr patt_imp g (l1 ++ l2) --->
   foldr patt_imp g (l1 ++ h :: l2))
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp g (l1 ++ l2) --->
   foldr patt_imp g (l1 ++ [h] ++ l2)
using BasicReasoning
Γ Ⱶ
a --->
foldr patt_imp g (l1 ++ l2) --->
foldr patt_imp g (l1 ++ [h] ++ l2)
using BasicReasoning

      {
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp g (l1 ++ l2) --->
   foldr patt_imp g (l1 ++ [h] ++ l2)
using BasicReasoning
well_formed
  (a --->
   foldr patt_imp g (l1 ++ l2) --->
   foldr patt_imp g (l1 ++ h :: l2)) wf_auto2. }
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp g (l1 ++ l2) --->
   foldr patt_imp g (l1 ++ [h] ++ l2)
using BasicReasoning
Γ Ⱶ
a --->
foldr patt_imp g (l1 ++ l2) --->
foldr patt_imp g (l1 ++ [h] ++ l2)
using BasicReasoning

      mlAdd IHl1 as "H0".
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp g (l1 ++ l2) --->
   foldr patt_imp g (l1 ++ [h] ++ l2)
using BasicReasoning
Γ Ⱶ
"H0" ∶ foldr patt_imp g (l1 ++ l2) --->
       foldr patt_imp g (l1 ++ [h] ++ l2),
--------------------------------------
a --->
foldr patt_imp g (l1 ++ l2) --->
foldr patt_imp g (l1 ++ [h] ++ l2)
using BasicReasoning

      mlIntro "H1".
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp g (l1 ++ l2) --->
   foldr patt_imp g (l1 ++ [h] ++ l2)
using BasicReasoning
Γ Ⱶ
"H0" ∶ foldr patt_imp g (l1 ++ l2) --->
       foldr patt_imp g (l1 ++ [h] ++ l2),
"H1" ∶ a,
--------------------------------------
foldr patt_imp g (l1 ++ l2) --->
foldr patt_imp g (l1 ++ [h] ++ l2)
using BasicReasoning
 mlExact "H0".
    }
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp g (l1 ++ l2) --->
   foldr patt_imp g (l1 ++ [h] ++ l2)
using BasicReasoning
H1: Γ
⊢i a --->
   foldr patt_imp g (l1 ++ l2) --->
   foldr patt_imp g (l1 ++ [h] ++ l2)
using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp g (l1 ++ l2)) --->
   a ---> foldr patt_imp g (l1 ++ h :: l2)
using BasicReasoning
    apply prf_impl_distr_meta; try_wfauto2.
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ
⊢i foldr patt_imp g (l1 ++ l2) --->
   foldr patt_imp g (l1 ++ [h] ++ l2)
using BasicReasoning
H1: Γ
⊢i a --->
   foldr patt_imp g (l1 ++ l2) --->
   foldr patt_imp g (l1 ++ [h] ++ l2)
using BasicReasoning
Γ
⊢i a --->
   foldr patt_imp g (l1 ++ l2) --->
   foldr patt_imp g (l1 ++ h :: l2)
using BasicReasoning apply H1.
Defined.

Lemma prf_clear_hyp_meta {Σ : Signature} Γ l1 l2 g h i:
  Pattern.wf l1 ->
  Pattern.wf l2 ->
  well_formed g ->
  well_formed h ->
  Γ ⊢i (foldr patt_imp g (l1 ++ l2)) using i ->
  Γ ⊢i (foldr patt_imp g (l1 ++ [h] ++ l2)) using i.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
Pattern.wf l1
→ Pattern.wf l2
  → well_formed g
    → well_formed h
      → Γ ⊢i foldr patt_imp g (l1 ++ l2) using i
        → Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2)
          using i
Proof.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
Pattern.wf l1
→ Pattern.wf l2
  → well_formed g
    → well_formed h
      → Γ ⊢i foldr patt_imp g (l1 ++ l2) using i
        → Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2)
          using i
  intros.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
H: Pattern.wf l1
H0: Pattern.wf l2
H1: well_formed g
H2: well_formed h
H3: Γ ⊢i foldr patt_imp g (l1 ++ l2) using i
Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i eapply MP.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
H: Pattern.wf l1
H0: Pattern.wf l2
H1: well_formed g
H2: well_formed h
H3: Γ ⊢i foldr patt_imp g (l1 ++ l2) using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
H: Pattern.wf l1
H0: Pattern.wf l2
H1: well_formed g
H2: well_formed h
H3: Γ ⊢i foldr patt_imp g (l1 ++ l2) using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp g (l1 ++ [h] ++ l2)
using i
  apply H3.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
H: Pattern.wf l1
H0: Pattern.wf l2
H1: well_formed g
H2: well_formed h
H3: Γ ⊢i foldr patt_imp g (l1 ++ l2) using i
Γ
⊢i foldr patt_imp g (l1 ++ l2) --->
   foldr patt_imp g (l1 ++ [h] ++ l2) using i
  useBasicReasoning.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
H: Pattern.wf l1
H0: Pattern.wf l2
H1: well_formed g
H2: well_formed h
H3: Γ ⊢i foldr patt_imp g (l1 ++ l2) using i
Γ
⊢i foldr patt_imp g (l1 ++ l2) --->
   foldr patt_imp g (l1 ++ [h] ++ l2)
using BasicReasoning
  apply prf_clear_hyp; wf_auto2.
Defined.  



Lemma mlGoal_clear_hyp {Σ : Signature} Γ l1 l2 g h i:
  mkMLGoal Σ Γ (l1 ++ l2) g i ->
  mkMLGoal Σ Γ (l1 ++ h::l2) g i.
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
Γ Ⱶ
l1 ++ l2--------------------------------------
g
using i

→ Γ Ⱶ
l1 ++ h :: l2--------------------------------------
g
using i

Proof.
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
Γ Ⱶ
l1 ++ l2--------------------------------------
g
using i

→ Γ Ⱶ
l1 ++ h :: l2--------------------------------------
g
using i

  intros H1.
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: Γ Ⱶ
l1 ++ l2--------------------------------------
g
using i

Γ Ⱶ
l1 ++ h :: l2--------------------------------------
g
using i

  unfold of_MLGoal in *.
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l1 ++ l2--------------------------------------
      g
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l1 ++ l2--------------------------------------
           g
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       l1 ++ l2--------------------------------------
       g
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l1 ++ l2--------------------------------------
             g
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l1 ++ l2--------------------------------------
                g
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             l1 ++ l2--------------------------------------
             g
             using i
             )
well_formed
  (mlConclusion
     (Γ Ⱶ
      l1 ++ h :: l2--------------------------------------
      g
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l1 ++ h :: l2--------------------------------------
           g
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       l1 ++ h :: l2--------------------------------------
       g
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l1 ++ h :: l2--------------------------------------
             g
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l1 ++ h :: l2--------------------------------------
                g
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             l1 ++ h :: l2--------------------------------------
             g
             using i
             ) simpl in *.
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g
→ Pattern.wf (patterns_of (l1 ++ l2))
  → Γ
    ⊢i foldr patt_imp g (patterns_of (l1 ++ l2))
    using i
well_formed g
→ Pattern.wf (patterns_of (l1 ++ h :: l2))
  → Γ
    ⊢i foldr patt_imp g (patterns_of (l1 ++ h :: l2))
    using i intros wfg wfl1hl2.
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g
→ Pattern.wf (patterns_of (l1 ++ l2))
  → Γ
    ⊢i foldr patt_imp g (patterns_of (l1 ++ l2))
    using i
wfg: well_formed g
wfl1hl2: Pattern.wf (patterns_of (l1 ++ h :: l2))
Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ h :: l2))
using i
  unfold patterns_of in *.
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g
→ Pattern.wf (map nh_patt (l1 ++ l2))
  → Γ
    ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2))
    using i
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt (l1 ++ h :: l2))
Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ h :: l2))
using i rewrite map_app.
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g
→ Pattern.wf (map nh_patt (l1 ++ l2))
  → Γ
    ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2))
    using i
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt (l1 ++ h :: l2))
Γ
⊢i foldr patt_imp g
     (map nh_patt l1 ++ map nh_patt (h :: l2)) using i
  rewrite map_app in wfl1hl2; simpl in wfl1hl2.
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g
→ Pattern.wf (map nh_patt (l1 ++ l2))
  → Γ
    ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2))
    using i
wfg: well_formed g
wfl1hl2: Pattern.wf
  (map nh_patt l1 ++
   nh_patt h :: map nh_patt l2)
Γ
⊢i foldr patt_imp g
     (map nh_patt l1 ++ map nh_patt (h :: l2)) using i
  apply prf_clear_hyp_meta.
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g
→ Pattern.wf (map nh_patt (l1 ++ l2))
  → Γ
    ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2))
    using i
wfg: well_formed g
wfl1hl2: Pattern.wf
  (map nh_patt l1 ++
   nh_patt h :: map nh_patt l2)
Pattern.wf (map nh_patt l1)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g
→ Pattern.wf (map nh_patt (l1 ++ l2))
  → Γ
    ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2))
    using i
wfg: well_formed g
wfl1hl2: Pattern.wf
  (map nh_patt l1 ++
   nh_patt h :: map nh_patt l2)
Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l2)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g
→ Pattern.wf (map nh_patt (l1 ++ l2))
  → Γ
    ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2))
    using i
wfg: well_formed g
wfl1hl2: Pattern.wf
  (map nh_patt l1 ++
   nh_patt h :: map nh_patt l2)
well_formed g
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g
→ Pattern.wf (map nh_patt (l1 ++ l2))
  → Γ
    ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2))
    using i
wfg: well_formed g
wfl1hl2: Pattern.wf
  (map nh_patt l1 ++
   nh_patt h :: map nh_patt l2)
well_formed (nh_patt h)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g
→ Pattern.wf (map nh_patt (l1 ++ l2))
  → Γ
    ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2))
    using i
wfg: well_formed g
wfl1hl2: Pattern.wf
  (map nh_patt l1 ++
   nh_patt h :: map nh_patt l2)
Γ
⊢i foldr patt_imp g
     (map nh_patt l1 ++
      (fix map (l : list named_hypothesis) :
           list Pattern :=
         match l with
         | [] => []
         | a :: t => nh_patt a :: map t
         end) l2) using i
  5: rewrite map_app in H1; apply H1.
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g
→ Pattern.wf (map nh_patt (l1 ++ l2))
  → Γ
    ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2))
    using i
wfg: well_formed g
wfl1hl2: Pattern.wf
  (map nh_patt l1 ++
   nh_patt h :: map nh_patt l2)
Pattern.wf (map nh_patt l1)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g
→ Pattern.wf (map nh_patt (l1 ++ l2))
  → Γ
    ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2))
    using i
wfg: well_formed g
wfl1hl2: Pattern.wf
  (map nh_patt l1 ++
   nh_patt h :: map nh_patt l2)
Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l2)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g
→ Pattern.wf (map nh_patt (l1 ++ l2))
  → Γ
    ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2))
    using i
wfg: well_formed g
wfl1hl2: Pattern.wf
  (map nh_patt l1 ++
   nh_patt h :: map nh_patt l2)
well_formed g
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g
→ Pattern.wf (map nh_patt (l1 ++ l2))
  → Γ
    ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2))
    using i
wfg: well_formed g
wfl1hl2: Pattern.wf
  (map nh_patt l1 ++
   nh_patt h :: map nh_patt l2)
well_formed (nh_patt h)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
wfg: well_formed g
wfl1hl2: Pattern.wf
  (map nh_patt l1 ++
   nh_patt h :: map nh_patt l2)
H1: well_formed g
→ Pattern.wf (map nh_patt l1 ++ map nh_patt l2)
  → Γ
    ⊢i foldr patt_imp g
         (map nh_patt l1 ++ map nh_patt l2)
    using i
well_formed g
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
wfg: well_formed g
wfl1hl2: Pattern.wf
  (map nh_patt l1 ++
   nh_patt h :: map nh_patt l2)
H1: well_formed g
→ Pattern.wf (map nh_patt l1 ++ map nh_patt l2)
  → Γ
    ⊢i foldr patt_imp g
         (map nh_patt l1 ++ map nh_patt l2)
    using i
Pattern.wf (map nh_patt l1 ++ map nh_patt l2) all: try assumption.
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g
→ Pattern.wf (map nh_patt (l1 ++ l2))
  → Γ
    ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2))
    using i
wfg: well_formed g
wfl1hl2: Pattern.wf
  (map nh_patt l1 ++
   nh_patt h :: map nh_patt l2)
Pattern.wf (map nh_patt l1)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g
→ Pattern.wf (map nh_patt (l1 ++ l2))
  → Γ
    ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2))
    using i
wfg: well_formed g
wfl1hl2: Pattern.wf
  (map nh_patt l1 ++
   nh_patt h :: map nh_patt l2)
Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l2)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g
→ Pattern.wf (map nh_patt (l1 ++ l2))
  → Γ
    ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2))
    using i
wfg: well_formed g
wfl1hl2: Pattern.wf
  (map nh_patt l1 ++
   nh_patt h :: map nh_patt l2)
well_formed (nh_patt h)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
wfg: well_formed g
wfl1hl2: Pattern.wf
  (map nh_patt l1 ++
   nh_patt h :: map nh_patt l2)
H1: well_formed g
→ Pattern.wf (map nh_patt l1 ++ map nh_patt l2)
  → Γ
    ⊢i foldr patt_imp g
         (map nh_patt l1 ++ map nh_patt l2)
    using i
Pattern.wf (map nh_patt l1 ++ map nh_patt l2)
  {
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g
→ Pattern.wf (map nh_patt (l1 ++ l2))
  → Γ
    ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2))
    using i
wfg: well_formed g
wfl1hl2: Pattern.wf
  (map nh_patt l1 ++
   nh_patt h :: map nh_patt l2)
Pattern.wf (map nh_patt l1) apply wfl₁hl₂_proj_l₁ in wfl1hl2.
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g
→ Pattern.wf (map nh_patt (l1 ++ l2))
  → Γ
    ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2))
    using i
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1)
Pattern.wf (map nh_patt l1) exact wfl1hl2. }
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g
→ Pattern.wf (map nh_patt (l1 ++ l2))
  → Γ
    ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2))
    using i
wfg: well_formed g
wfl1hl2: Pattern.wf
  (map nh_patt l1 ++
   nh_patt h :: map nh_patt l2)
Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l2)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g
→ Pattern.wf (map nh_patt (l1 ++ l2))
  → Γ
    ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2))
    using i
wfg: well_formed g
wfl1hl2: Pattern.wf
  (map nh_patt l1 ++
   nh_patt h :: map nh_patt l2)
well_formed (nh_patt h)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
wfg: well_formed g
wfl1hl2: Pattern.wf
  (map nh_patt l1 ++
   nh_patt h :: map nh_patt l2)
H1: well_formed g
→ Pattern.wf (map nh_patt l1 ++ map nh_patt l2)
  → Γ
    ⊢i foldr patt_imp g
         (map nh_patt l1 ++ map nh_patt l2)
    using i
Pattern.wf (map nh_patt l1 ++ map nh_patt l2)
  {
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g
→ Pattern.wf (map nh_patt (l1 ++ l2))
  → Γ
    ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2))
    using i
wfg: well_formed g
wfl1hl2: Pattern.wf
  (map nh_patt l1 ++
   nh_patt h :: map nh_patt l2)
Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l2) apply wfl₁hl₂_proj_l₂ in wfl1hl2.
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g
→ Pattern.wf (map nh_patt (l1 ++ l2))
  → Γ
    ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2))
    using i
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l2)
Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l2) exact wfl1hl2. }
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g
→ Pattern.wf (map nh_patt (l1 ++ l2))
  → Γ
    ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2))
    using i
wfg: well_formed g
wfl1hl2: Pattern.wf
  (map nh_patt l1 ++
   nh_patt h :: map nh_patt l2)
well_formed (nh_patt h)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
wfg: well_formed g
wfl1hl2: Pattern.wf
  (map nh_patt l1 ++
   nh_patt h :: map nh_patt l2)
H1: well_formed g
→ Pattern.wf (map nh_patt l1 ++ map nh_patt l2)
  → Γ
    ⊢i foldr patt_imp g
         (map nh_patt l1 ++ map nh_patt l2)
    using i
Pattern.wf (map nh_patt l1 ++ map nh_patt l2)
  {
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g
→ Pattern.wf (map nh_patt (l1 ++ l2))
  → Γ
    ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2))
    using i
wfg: well_formed g
wfl1hl2: Pattern.wf
  (map nh_patt l1 ++
   nh_patt h :: map nh_patt l2)
well_formed (nh_patt h) apply wfl₁hl₂_proj_h in wfl1hl2.
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g
→ Pattern.wf (map nh_patt (l1 ++ l2))
  → Γ
    ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2))
    using i
wfg: well_formed g
wfl1hl2: well_formed (nh_patt h)
well_formed (nh_patt h) exact wfl1hl2. }
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
wfg: well_formed g
wfl1hl2: Pattern.wf
  (map nh_patt l1 ++
   nh_patt h :: map nh_patt l2)
H1: well_formed g
→ Pattern.wf (map nh_patt l1 ++ map nh_patt l2)
  → Γ
    ⊢i foldr patt_imp g
         (map nh_patt l1 ++ map nh_patt l2)
    using i
Pattern.wf (map nh_patt l1 ++ map nh_patt l2)
  {
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
wfg: well_formed g
wfl1hl2: Pattern.wf
  (map nh_patt l1 ++
   nh_patt h :: map nh_patt l2)
H1: well_formed g
→ Pattern.wf (map nh_patt l1 ++ map nh_patt l2)
  → Γ
    ⊢i foldr patt_imp g
         (map nh_patt l1 ++ map nh_patt l2)
    using i
Pattern.wf (map nh_patt l1 ++ map nh_patt l2) apply wfl₁hl₂_proj_l₁l₂ in wfl1hl2.
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
wfg: well_formed g
wfl1hl2: Pattern.wf
  (map nh_patt l1 ++ map nh_patt l2)
H1: well_formed g
→ Pattern.wf (map nh_patt l1 ++ map nh_patt l2)
  → Γ
    ⊢i foldr patt_imp g
         (map nh_patt l1 ++ map nh_patt l2)
    using i
Pattern.wf (map nh_patt l1 ++ map nh_patt l2) exact wfl1hl2. }
Defined.


Tactic Notation "mlClear" constr(name) :=
  _ensureProofMode;
  _mlReshapeHypsByName name; apply mlGoal_clear_hyp; _mlReshapeHypsBack.

Local Example ex_mlClear {Σ : Signature} Γ a b c:
  well_formed a ->
  well_formed b ->
  well_formed c ->
  Γ ⊢i a ---> (b ---> (c ---> b)) using BasicReasoning.
Σ: Signature
Γ: Theory
a, b, c: Pattern
well_formed a
→ well_formed b
  → well_formed c
    → Γ ⊢i a ---> b ---> c ---> b using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
a, b, c: Pattern
well_formed a
→ well_formed b
  → well_formed c
    → Γ ⊢i a ---> b ---> c ---> b using BasicReasoning
  intros wfa wfb wfc.
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ ⊢i a ---> b ---> c ---> b using BasicReasoning
  toMLGoal.
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
well_formed (a ---> b ---> c ---> b)
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ Ⱶ
a ---> b ---> c ---> b
using BasicReasoning

  {
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
well_formed (a ---> b ---> c ---> b) wf_auto2. }
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ Ⱶ
a ---> b ---> c ---> b
using BasicReasoning

  mlIntro "H0".
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ Ⱶ
"H0" ∶ a,
--------------------------------------
b ---> c ---> b
using BasicReasoning
 mlIntro "H1".
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ b,
--------------------------------------
c ---> b
using BasicReasoning
 mlIntro "H2".
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ b,
"H2" ∶ c,
--------------------------------------
b
using BasicReasoning

  mlClear "H2".
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ b,
--------------------------------------
b
using BasicReasoning

  mlClear "H0".
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ Ⱶ
"H1" ∶ b,
--------------------------------------
b
using BasicReasoning

  mlExact "H1".
Defined.


Lemma not_concl {Σ : Signature} Γ p q:
  well_formed p ->
  well_formed q ->
  Γ ⊢i (p ---> (q ---> ((p ---> ! q) ---> ⊥))) using BasicReasoning.
Σ: Signature
Γ: Theory
p, q: Pattern
well_formed p
→ well_formed q
  → Γ ⊢i p ---> q ---> (p ---> ! q) ---> ⊥
    using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
p, q: Pattern
well_formed p
→ well_formed q
  → Γ ⊢i p ---> q ---> (p ---> ! q) ---> ⊥
    using BasicReasoning
  intros wfp wfq.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ ⊢i p ---> q ---> (p ---> ! q) ---> ⊥
using BasicReasoning
  eapply cast_proof'.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
(p ---> q ---> (p ---> ! q) ---> ⊥) = ?ϕ
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ ⊢i ?ϕ using BasicReasoning
  {
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
(p ---> q ---> (p ---> ! q) ---> ⊥) = ?ϕ
    rewrite [(p ---> q ---> (p ---> ! q) ---> ⊥)]tofold.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
foldr patt_imp (p ---> q ---> (p ---> ! q) ---> ⊥) [] =
?ϕ
    do 3 rewrite consume.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
foldr patt_imp ⊥
  ((([] ++ [p]) ++ [q]) ++ [p ---> ! q]) = ?ϕ
    rewrite [(((nil ++ [p]) ++ [q]) ++ [p ---> ! q])]/=.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
foldr patt_imp ⊥ [p; q; p ---> ! q] = ?ϕ
    replace ([p; q; p--->!q]) with ([p] ++ [q; p ---> !q] ++ []) by reflexivity.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
foldr patt_imp ⊥ ([p] ++ [q; p ---> ! q] ++ []) = ?ϕ
    reflexivity.
  }
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ ⊢i foldr patt_imp ⊥ ([p] ++ [q; p ---> ! q] ++ [])
using BasicReasoning
  apply prf_reorder_iter_meta; try_wfauto2.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ ⊢i foldr patt_imp ⊥ ([p] ++ [p ---> ! q; q] ++ [])
using BasicReasoning
  simpl.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ ⊢i p ---> (p ---> ! q) ---> q ---> ⊥
using BasicReasoning
  fold (! q).
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ ⊢i p ---> (p ---> ! q) ---> ! q using BasicReasoning
  apply modus_ponens; wf_auto2.
Defined.

Lemma reorder_last_to_head {Σ : Signature} Γ g x l:
  Pattern.wf l ->
  well_formed g ->
  well_formed x ->
  Γ ⊢i ((foldr patt_imp g (x::l)) ---> (foldr patt_imp g (l ++ [x]))) using BasicReasoning.
Σ: Signature
Γ: Theory
g, x: Pattern
l: list Pattern
Pattern.wf l
→ well_formed g
  → well_formed x
    → Γ
      ⊢i foldr patt_imp g (x :: l) --->
         foldr patt_imp g (l ++ [x])
      using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
g, x: Pattern
l: list Pattern
Pattern.wf l
→ well_formed g
  → well_formed x
    → Γ
      ⊢i foldr patt_imp g (x :: l) --->
         foldr patt_imp g (l ++ [x])
      using BasicReasoning
  intros wfl wfg wfx.
Σ: Signature
Γ: Theory
g, x: Pattern
l: list Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfx: well_formed x
Γ
⊢i foldr patt_imp g (x :: l) --->
   foldr patt_imp g (l ++ [x]) using BasicReasoning
  induction l.
Σ: Signature
Γ: Theory
g, x: Pattern
wfl: Pattern.wf []
wfg: well_formed g
wfx: well_formed x
Γ
⊢i foldr patt_imp g [x] --->
   foldr patt_imp g ([] ++ [x]) using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfl: Pattern.wf (a :: l)
wfg: well_formed g
wfx: well_formed x
IHl: Pattern.wf l
→ Γ ⊢i foldr patt_imp g (x :: l) ---> foldr patt_imp g (l ++ [x])
using BasicReasoning
Γ
⊢i foldr patt_imp g (x :: a :: l) --->
   foldr patt_imp g ((a :: l) ++ [x])
using BasicReasoning
  -
Σ: Signature
Γ: Theory
g, x: Pattern
wfl: Pattern.wf []
wfg: well_formed g
wfx: well_formed x
Γ
⊢i foldr patt_imp g [x] --->
   foldr patt_imp g ([] ++ [x]) using BasicReasoning simpl.
Σ: Signature
Γ: Theory
g, x: Pattern
wfl: Pattern.wf []
wfg: well_formed g
wfx: well_formed x
Γ ⊢i (x ---> g) ---> x ---> g using BasicReasoning apply A_impl_A.
Σ: Signature
Γ: Theory
g, x: Pattern
wfl: Pattern.wf []
wfg: well_formed g
wfx: well_formed x
well_formed (x ---> g) wf_auto2.
  -
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfl: Pattern.wf (a :: l)
wfg: well_formed g
wfx: well_formed x
IHl: Pattern.wf l
→ Γ ⊢i foldr patt_imp g (x :: l) ---> foldr patt_imp g (l ++ [x])
using BasicReasoning
Γ
⊢i foldr patt_imp g (x :: a :: l) --->
   foldr patt_imp g ((a :: l) ++ [x])
using BasicReasoning pose proof (wfal := wfl).
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfl: Pattern.wf (a :: l)
wfg: well_formed g
wfx: well_formed x
IHl: Pattern.wf l
→ Γ ⊢i foldr patt_imp g (x :: l) ---> foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i foldr patt_imp g (x :: a :: l) --->
   foldr patt_imp g ((a :: l) ++ [x])
using BasicReasoning
    unfold Pattern.wf in wfl.
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfl: foldr andb true (map well_formed (a :: l))
wfg: well_formed g
wfx: well_formed x
IHl: Pattern.wf l
→ Γ ⊢i foldr patt_imp g (x :: l) ---> foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i foldr patt_imp g (x :: a :: l) --->
   foldr patt_imp g ((a :: l) ++ [x])
using BasicReasoning simpl in wfl.
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfl: well_formed a && foldr andb true (map well_formed l)
wfg: well_formed g
wfx: well_formed x
IHl: Pattern.wf l
→ Γ ⊢i foldr patt_imp g (x :: l) ---> foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i foldr patt_imp g (x :: a :: l) --->
   foldr patt_imp g ((a :: l) ++ [x])
using BasicReasoning apply andb_prop in wfl.
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfl: well_formed a = true ∧ foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Pattern.wf l
→ Γ ⊢i foldr patt_imp g (x :: l) ---> foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i foldr patt_imp g (x :: a :: l) --->
   foldr patt_imp g ((a :: l) ++ [x])
using BasicReasoning destruct wfl as [wfa wfl].
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Pattern.wf l
→ Γ ⊢i foldr patt_imp g (x :: l) ---> foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i foldr patt_imp g (x :: a :: l) --->
   foldr patt_imp g ((a :: l) ++ [x])
using BasicReasoning
    specialize (IHl wfl).
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i foldr patt_imp g (x :: l) ---> foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i foldr patt_imp g (x :: a :: l) --->
   foldr patt_imp g ((a :: l) ++ [x])
using BasicReasoning
    simpl.
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i foldr patt_imp g (x :: l) ---> foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i (x ---> a ---> foldr patt_imp g l) --->
   a ---> foldr patt_imp g (l ++ [x])
using BasicReasoning simpl in IHl.
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i (x ---> a ---> foldr patt_imp g l) --->
   a ---> foldr patt_imp g (l ++ [x])
using BasicReasoning
    eapply cast_proof'.
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
((x ---> a ---> foldr patt_imp g l) --->
 a ---> foldr patt_imp g (l ++ [x])) = ?ϕ
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ
⊢i (x ---> foldr patt_imp g l) --->
   foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ ⊢i ?ϕ using BasicReasoning
    {
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
((x ---> a ---> foldr patt_imp g l) --->
 a ---> foldr patt_imp g (l ++ [x])) = ?ϕ rewrite -> tofold at 1.
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
foldr patt_imp
  ((x ---> a ---> foldr patt_imp g l) --->
   a ---> foldr patt_imp g (l ++ [x])) [] = ?ϕ repeat rewrite -> consume.
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
foldr patt_imp (foldr patt_imp g (l ++ [x]))
  (([] ++ [x ---> a ---> foldr patt_imp g l]) ++ [a]) =
?ϕ reflexivity. }
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i foldr patt_imp (foldr patt_imp g (l ++ [x]))
     (([] ++ [x ---> a ---> foldr patt_imp g l]) ++
      [a]) using BasicReasoning
    eapply prf_weaken_conclusion_iter_meta_meta.
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Pattern.wf
  (([] ++ [x ---> a ---> foldr patt_imp g l]) ++ [a])
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ
⊢i (x ---> foldr patt_imp g l) --->
   foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
well_formed ?g
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ
⊢i (x ---> foldr patt_imp g l) --->
   foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
well_formed (foldr patt_imp g (l ++ [x]))
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ
⊢i (x ---> foldr patt_imp g l) --->
   foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ ⊢i ?g ---> foldr patt_imp g (l ++ [x])
using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ
⊢i (x ---> foldr patt_imp g l) --->
   foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i foldr patt_imp ?g
     (([] ++ [x ---> a ---> foldr patt_imp g l]) ++
      [a]) using BasicReasoning
    4: {
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ ⊢i ?g ---> foldr patt_imp g (l ++ [x])
using BasicReasoning apply IHl. }
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Pattern.wf
  (([] ++ [x ---> a ---> foldr patt_imp g l]) ++ [a])
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ
⊢i (x ---> foldr patt_imp g l) --->
   foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
well_formed (x ---> foldr patt_imp g l)
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ
⊢i (x ---> foldr patt_imp g l) --->
   foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
well_formed (foldr patt_imp g (l ++ [x]))
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ
⊢i (x ---> foldr patt_imp g l) --->
   foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i foldr patt_imp (x ---> foldr patt_imp g l)
     (([] ++ [x ---> a ---> foldr patt_imp g l]) ++
      [a]) using BasicReasoning
    all: try_wfauto2.
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i foldr patt_imp (x ---> foldr patt_imp g l)
     (([] ++ [x ---> a ---> foldr patt_imp g l]) ++
      [a]) using BasicReasoning
    eapply cast_proof'.
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
foldr patt_imp (x ---> foldr patt_imp g l)
  (([] ++ [x ---> a ---> foldr patt_imp g l]) ++ [a]) =
?ϕ
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ
⊢i (x ---> foldr patt_imp g l) --->
   foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ ⊢i ?ϕ using BasicReasoning
    {
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
foldr patt_imp (x ---> foldr patt_imp g l)
  (([] ++ [x ---> a ---> foldr patt_imp g l]) ++ [a]) =
?ϕ
      rewrite consume.
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
foldr patt_imp (foldr patt_imp g l)
  ((([] ++ [x ---> a ---> foldr patt_imp g l]) ++ [a]) ++
   [x]) = ?ϕ
      replace ((([] ++ [x ---> a ---> foldr patt_imp g l]) ++ [a]) ++ [x])
        with ([x ---> a ---> foldr patt_imp g l] ++ [a;x] ++ []) by reflexivity.
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
foldr patt_imp (foldr patt_imp g l)
  ([x ---> a ---> foldr patt_imp g l] ++ [a; x] ++ []) =
?ϕ
      reflexivity.
    }
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i foldr patt_imp (foldr patt_imp g l)
     ([x ---> a ---> foldr patt_imp g l] ++
      [a; x] ++ []) using BasicReasoning
    apply prf_reorder_iter_meta; wf_auto2.
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfl: foldr andb true
(map
(λ phi : Pattern,
[&& well_formed_positive phi, well_formed_closed_mu_aux phi 0
 & well_formed_closed_ex_aux phi 0]) l) = true
H4: lwf_cmu 0 l = true
H3: well_formed_positive g = true
H14: well_formed_closed_ex_aux g 0 = true
H13: well_formed_closed_mu_aux g 0 = true
H5: well_formed_positive x = true
H12: well_formed_closed_ex_aux x 0 = true
H11: well_formed_closed_mu_aux x 0 = true
H7, H2: true = true
H6: well_formed_positive a = true
H10: well_formed_closed_ex_aux a 0 = true
H9: well_formed_closed_mu_aux a 0 = true
H1: lwf_positive l = true
H0: lwf_cex 0 l = true
H15: true = true
Γ
⊢i (x ---> a ---> foldr patt_imp g l) --->
   x ---> a ---> foldr patt_imp g l
using BasicReasoning
    simpl.
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfl: foldr andb true
(map
(λ phi : Pattern,
[&& well_formed_positive phi, well_formed_closed_mu_aux phi 0
 & well_formed_closed_ex_aux phi 0]) l) = true
H4: lwf_cmu 0 l = true
H3: well_formed_positive g = true
H14: well_formed_closed_ex_aux g 0 = true
H13: well_formed_closed_mu_aux g 0 = true
H5: well_formed_positive x = true
H12: well_formed_closed_ex_aux x 0 = true
H11: well_formed_closed_mu_aux x 0 = true
H7, H2: true = true
H6: well_formed_positive a = true
H10: well_formed_closed_ex_aux a 0 = true
H9: well_formed_closed_mu_aux a 0 = true
H1: lwf_positive l = true
H0: lwf_cex 0 l = true
H15: true = true
Γ
⊢i (x ---> a ---> foldr patt_imp g l) --->
   x ---> a ---> foldr patt_imp g l
using BasicReasoning apply A_impl_A.
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfl: foldr andb true
(map
(λ phi : Pattern,
[&& well_formed_positive phi, well_formed_closed_mu_aux phi 0
 & well_formed_closed_ex_aux phi 0]) l) = true
H4: lwf_cmu 0 l = true
H3: well_formed_positive g = true
H14: well_formed_closed_ex_aux g 0 = true
H13: well_formed_closed_mu_aux g 0 = true
H5: well_formed_positive x = true
H12: well_formed_closed_ex_aux x 0 = true
H11: well_formed_closed_mu_aux x 0 = true
H7, H2: true = true
H6: well_formed_positive a = true
H10: well_formed_closed_ex_aux a 0 = true
H9: well_formed_closed_mu_aux a 0 = true
H1: lwf_positive l = true
H0: lwf_cex 0 l = true
H15: true = true
well_formed (x ---> a ---> foldr patt_imp g l) wf_auto2.
Defined.

Lemma reorder_last_to_head_meta {Σ : Signature} Γ g x l i:
  Pattern.wf l ->
  well_formed g ->
  well_formed x ->
  Γ ⊢i (foldr patt_imp g (x::l)) using i ->
  Γ ⊢i (foldr patt_imp g (l ++ [x])) using i.
Σ: Signature
Γ: Theory
g, x: Pattern
l: list Pattern
i: ProofInfo
Pattern.wf l
→ well_formed g
  → well_formed x
    → Γ ⊢i foldr patt_imp g (x :: l) using i
      → Γ ⊢i foldr patt_imp g (l ++ [x]) using i
Proof.
Σ: Signature
Γ: Theory
g, x: Pattern
l: list Pattern
i: ProofInfo
Pattern.wf l
→ well_formed g
  → well_formed x
    → Γ ⊢i foldr patt_imp g (x :: l) using i
      → Γ ⊢i foldr patt_imp g (l ++ [x]) using i
  intros WFl WFG WFx H.
Σ: Signature
Γ: Theory
g, x: Pattern
l: list Pattern
i: ProofInfo
WFl: Pattern.wf l
WFG: well_formed g
WFx: well_formed x
H: Γ ⊢i foldr patt_imp g (x :: l) using i
Γ ⊢i foldr patt_imp g (l ++ [x]) using i
  eapply MP.
Σ: Signature
Γ: Theory
g, x: Pattern
l: list Pattern
i: ProofInfo
WFl: Pattern.wf l
WFG: well_formed g
WFx: well_formed x
H: Γ ⊢i foldr patt_imp g (x :: l) using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
g, x: Pattern
l: list Pattern
i: ProofInfo
WFl: Pattern.wf l
WFG: well_formed g
WFx: well_formed x
H: Γ ⊢i foldr patt_imp g (x :: l) using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp g (l ++ [x]) using i
  apply H.
Σ: Signature
Γ: Theory
g, x: Pattern
l: list Pattern
i: ProofInfo
WFl: Pattern.wf l
WFG: well_formed g
WFx: well_formed x
H: Γ ⊢i foldr patt_imp g (x :: l) using i
Γ
⊢i foldr patt_imp g (x :: l) --->
   foldr patt_imp g (l ++ [x]) using i
  useBasicReasoning.
Σ: Signature
Γ: Theory
g, x: Pattern
l: list Pattern
i: ProofInfo
WFl: Pattern.wf l
WFG: well_formed g
WFx: well_formed x
H: Γ ⊢i foldr patt_imp g (x :: l) using i
Γ
⊢i foldr patt_imp g (x :: l) --->
   foldr patt_imp g (l ++ [x]) using BasicReasoning
  apply reorder_last_to_head; wf_auto2.
Defined.

(* Iterated modus ponens.
 For l = [x₁, ..., xₙ], it says that
 Γ ⊢i ((x₁ -> ... -> xₙ -> (x₁ -> ... -> xₙ -> r)) -> r)
*)
Lemma modus_ponens_iter {Σ : Signature} Γ l r:
  Pattern.wf l ->
  well_formed r ->
  Γ ⊢i (foldr patt_imp r (l ++ [foldr patt_imp r l])) using BasicReasoning.
Σ: Signature
Γ: Theory
l: list Pattern
r: Pattern
Pattern.wf l
→ well_formed r
  → Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l])
    using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
l: list Pattern
r: Pattern
Pattern.wf l
→ well_formed r
  → Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l])
    using BasicReasoning
  intros wfl wfr.
Σ: Signature
Γ: Theory
l: list Pattern
r: Pattern
wfl: Pattern.wf l
wfr: well_formed r
Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l])
using BasicReasoning
  induction l.
Σ: Signature
Γ: Theory
r: Pattern
wfl: Pattern.wf []
wfr: well_formed r
Γ ⊢i foldr patt_imp r ([] ++ [foldr patt_imp r []])
using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfl: Pattern.wf (a :: l)
wfr: well_formed r
IHl: Pattern.wf l
→ Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
Γ
⊢i foldr patt_imp r
     ((a :: l) ++ [foldr patt_imp r (a :: l)])
using BasicReasoning
  -
Σ: Signature
Γ: Theory
r: Pattern
wfl: Pattern.wf []
wfr: well_formed r
Γ ⊢i foldr patt_imp r ([] ++ [foldr patt_imp r []])
using BasicReasoning simpl.
Σ: Signature
Γ: Theory
r: Pattern
wfl: Pattern.wf []
wfr: well_formed r
Γ ⊢i r ---> r using BasicReasoning apply A_impl_A.
Σ: Signature
Γ: Theory
r: Pattern
wfl: Pattern.wf []
wfr: well_formed r
well_formed r exact wfr.
  -
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfl: Pattern.wf (a :: l)
wfr: well_formed r
IHl: Pattern.wf l
→ Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
Γ
⊢i foldr patt_imp r
     ((a :: l) ++ [foldr patt_imp r (a :: l)])
using BasicReasoning pose proof (wfal := wfl).
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfl: Pattern.wf (a :: l)
wfr: well_formed r
IHl: Pattern.wf l
→ Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i foldr patt_imp r
     ((a :: l) ++ [foldr patt_imp r (a :: l)])
using BasicReasoning
    unfold Pattern.wf in wfl.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfl: foldr andb true (map well_formed (a :: l))
wfr: well_formed r
IHl: Pattern.wf l
→ Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i foldr patt_imp r
     ((a :: l) ++ [foldr patt_imp r (a :: l)])
using BasicReasoning simpl in wfl.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfl: well_formed a && foldr andb true (map well_formed l)
wfr: well_formed r
IHl: Pattern.wf l
→ Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i foldr patt_imp r
     ((a :: l) ++ [foldr patt_imp r (a :: l)])
using BasicReasoning apply andb_prop in wfl.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfl: well_formed a = true ∧ foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Pattern.wf l
→ Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i foldr patt_imp r
     ((a :: l) ++ [foldr patt_imp r (a :: l)])
using BasicReasoning destruct wfl as [wfa wfl].
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Pattern.wf l
→ Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i foldr patt_imp r
     ((a :: l) ++ [foldr patt_imp r (a :: l)])
using BasicReasoning
    specialize (IHl wfl).
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i foldr patt_imp r
     ((a :: l) ++ [foldr patt_imp r (a :: l)])
using BasicReasoning
    simpl.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i a --->
   foldr patt_imp r (l ++ [a ---> foldr patt_imp r l])
using BasicReasoning
    eapply cast_proof'.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)
(a --->
 foldr patt_imp r (l ++ [a ---> foldr patt_imp r l])) =
?ϕ
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [foldr patt_imp r l])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ ⊢i ?ϕ using BasicReasoning
    {
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)
(a --->
 foldr patt_imp r (l ++ [a ---> foldr patt_imp r l])) =
?ϕ rewrite foldr_app.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)
(a --->
 foldr patt_imp
   (foldr patt_imp r [a ---> foldr patt_imp r l]) l) =
?ϕ simpl.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)
(a --->
 foldr patt_imp ((a ---> foldr patt_imp r l) ---> r) l) =
?ϕ rewrite consume.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)
(a --->
 foldr patt_imp r (l ++ [a ---> foldr patt_imp r l])) =
?ϕ simpl.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)
(a --->
 foldr patt_imp r (l ++ [a ---> foldr patt_imp r l])) =
?ϕ reflexivity. }
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i a --->
   foldr patt_imp r (l ++ [a ---> foldr patt_imp r l])
using BasicReasoning
    eapply cast_proof' in IHl.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ ⊢i ?ψ using BasicReasoning
Γ
⊢i a --->
   foldr patt_imp r (l ++ [a ---> foldr patt_imp r l])
using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [foldr patt_imp r l])
using BasicReasoning
wfal: Pattern.wf (a :: l)
?ψ = foldr patt_imp r (l ++ [foldr patt_imp r l])
    2: {
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)
?ψ = foldr patt_imp r (l ++ [foldr patt_imp r l]) rewrite foldr_app.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)
?ψ =
foldr patt_imp (foldr patt_imp r [foldr patt_imp r l])
  l reflexivity. }
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp
     (foldr patt_imp r [foldr patt_imp r l]) l
using BasicReasoning
Γ
⊢i a --->
   foldr patt_imp r (l ++ [a ---> foldr patt_imp r l])
using BasicReasoning
    simpl in IHl.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (foldr patt_imp r l ---> r) l
using BasicReasoning
Γ
⊢i a --->
   foldr patt_imp r (l ++ [a ---> foldr patt_imp r l])
using BasicReasoning
    eapply prf_weaken_conclusion_meta_meta.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (foldr patt_imp r l ---> r) l
using BasicReasoning
well_formed a
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (foldr patt_imp r l ---> r) l
using BasicReasoning
well_formed ?B
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (foldr patt_imp r l ---> r) l
using BasicReasoning
well_formed
  (foldr patt_imp r (l ++ [a ---> foldr patt_imp r l]))
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (foldr patt_imp r l ---> r) l
using BasicReasoning
Γ
⊢i ?B --->
   foldr patt_imp r (l ++ [a ---> foldr patt_imp r l])
using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (foldr patt_imp r l ---> r) l
using BasicReasoning
Γ ⊢i a ---> ?B using BasicReasoning
    4: {
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (foldr patt_imp r l ---> r) l
using BasicReasoning
Γ
⊢i ?B --->
   foldr patt_imp r (l ++ [a ---> foldr patt_imp r l])
using BasicReasoning apply reorder_last_to_head; wf_auto2. }
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (foldr patt_imp r l ---> r) l
using BasicReasoning
well_formed a
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (foldr patt_imp r l ---> r) l
using BasicReasoning
well_formed
  (foldr patt_imp r ((a ---> foldr patt_imp r l) :: l))
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (foldr patt_imp r l ---> r) l
using BasicReasoning
well_formed
  (foldr patt_imp r (l ++ [a ---> foldr patt_imp r l]))
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (foldr patt_imp r l ---> r) l
using BasicReasoning
Γ
⊢i a --->
   foldr patt_imp r ((a ---> foldr patt_imp r l) :: l)
using BasicReasoning
    all: try_wfauto2.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (foldr patt_imp r l ---> r) l
using BasicReasoning
Γ
⊢i a --->
   foldr patt_imp r ((a ---> foldr patt_imp r l) :: l)
using BasicReasoning
    simpl.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (foldr patt_imp r l ---> r) l
using BasicReasoning
Γ
⊢i a --->
   (a ---> foldr patt_imp r l) ---> foldr patt_imp r l
using BasicReasoning apply modus_ponens; wf_auto2.
Defined.

Lemma and_impl {Σ : Signature} Γ p q r:
  well_formed p ->
  well_formed q ->
  well_formed r ->
  Γ ⊢i ((p and q ---> r) ---> (p ---> (q ---> r))) using BasicReasoning.
Σ: Signature
Γ: Theory
p, q, r: Pattern
well_formed p
→ well_formed q
  → well_formed r
    → Γ ⊢i (p and q ---> r) ---> p ---> q ---> r
      using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
p, q, r: Pattern
well_formed p
→ well_formed q
  → well_formed r
    → Γ ⊢i (p and q ---> r) ---> p ---> q ---> r
      using BasicReasoning
  intros wfp wfq wfr.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Γ ⊢i (p and q ---> r) ---> p ---> q ---> r
using BasicReasoning
  toMLGoal.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
well_formed ((p and q ---> r) ---> p ---> q ---> r)
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Γ Ⱶ
(p and q ---> r) ---> p ---> q ---> r
using BasicReasoning

  {
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
well_formed ((p and q ---> r) ---> p ---> q ---> r) wf_auto2. }
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Γ Ⱶ
(p and q ---> r) ---> p ---> q ---> r
using BasicReasoning

  mlIntro "H0".
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Γ Ⱶ
"H0" ∶ p and q ---> r,
--------------------------------------
p ---> q ---> r
using BasicReasoning
 mlIntro "H2".
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Γ Ⱶ
"H0" ∶ p and q ---> r,
"H2" ∶ p,
--------------------------------------
q ---> r
using BasicReasoning
 mlIntro "H3".
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Γ Ⱶ
"H0" ∶ p and q ---> r,
"H2" ∶ p,
"H3" ∶ q,
--------------------------------------
r
using BasicReasoning

  unfold patt_and.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Γ Ⱶ
"H0" ∶ ! (! p or ! q) ---> r,
"H2" ∶ p,
"H3" ∶ q,
--------------------------------------
r
using BasicReasoning
 mlApply "H0".
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Γ Ⱶ
"H0" ∶ ! (! p or ! q) ---> r,
"H2" ∶ p,
"H3" ∶ q,
--------------------------------------
! (! p or ! q)
using BasicReasoning

  mlIntro "H4".
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Γ Ⱶ
"H0" ∶ ! (! p or ! q) ---> r,
"H2" ∶ p,
"H3" ∶ q,
"H4" ∶ ! p or ! q,
--------------------------------------
⊥
using BasicReasoning
 unfold patt_or at 2.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Γ Ⱶ
"H0" ∶ ! (! p or ! q) ---> r,
"H2" ∶ p,
"H3" ∶ q,
"H4" ∶ ! ! p ---> ! q,
--------------------------------------
⊥
using BasicReasoning

  mlAssert ("H5" : (! ! p)).
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
well_formed (! ! p)
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
Γ Ⱶ
"H0" ∶ ! (! p or ! q) ---> r,
"H2" ∶ p,
"H3" ∶ q,
"H4" ∶ ! ! p ---> ! q,
--------------------------------------
! ! p
using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
Γ Ⱶ
"H0" ∶ ! (! p or ! q) ---> r,
"H2" ∶ p,
"H3" ∶ q,
"H4" ∶ ! ! p ---> ! q,
"H5" ∶ ! ! p,
--------------------------------------
⊥
using BasicReasoning

  {
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
well_formed (! ! p) wf_auto2. }
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
Γ Ⱶ
"H0" ∶ ! (! p or ! q) ---> r,
"H2" ∶ p,
"H3" ∶ q,
"H4" ∶ ! ! p ---> ! q,
--------------------------------------
! ! p
using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
Γ Ⱶ
"H0" ∶ ! (! p or ! q) ---> r,
"H2" ∶ p,
"H3" ∶ q,
"H4" ∶ ! ! p ---> ! q,
"H5" ∶ ! ! p,
--------------------------------------
⊥
using BasicReasoning

  {
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
Γ Ⱶ
"H0" ∶ ! (! p or ! q) ---> r,
"H2" ∶ p,
"H3" ∶ q,
"H4" ∶ ! ! p ---> ! q,
--------------------------------------
! ! p
using BasicReasoning

    mlAdd (not_not_intro Γ p wfp) as "H6".
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
Γ Ⱶ
"H6" ∶ p ---> ! ! p,
"H0" ∶ ! (! p or ! q) ---> r,
"H2" ∶ p,
"H3" ∶ q,
"H4" ∶ ! ! p ---> ! q,
--------------------------------------
! ! p
using BasicReasoning

    mlApply "H6".
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
Γ Ⱶ
"H6" ∶ p ---> ! ! p,
"H0" ∶ ! (! p or ! q) ---> r,
"H2" ∶ p,
"H3" ∶ q,
"H4" ∶ ! ! p ---> ! q,
--------------------------------------
p
using BasicReasoning

    mlExact "H2".
  }
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
Γ Ⱶ
"H0" ∶ ! (! p or ! q) ---> r,
"H2" ∶ p,
"H3" ∶ q,
"H4" ∶ ! ! p ---> ! q,
"H5" ∶ ! ! p,
--------------------------------------
⊥
using BasicReasoning

  mlAssert ("H6" : (! q)).
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
well_formed (! q)
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
Hwf0: well_formed (! q)
Γ Ⱶ
"H0" ∶ ! (! p or ! q) ---> r,
"H2" ∶ p,
"H3" ∶ q,
"H4" ∶ ! ! p ---> ! q,
"H5" ∶ ! ! p,
--------------------------------------
! q
using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
Hwf0: well_formed (! q)
Γ Ⱶ
"H0" ∶ ! (! p or ! q) ---> r,
"H2" ∶ p,
"H3" ∶ q,
"H4" ∶ ! ! p ---> ! q,
"H5" ∶ ! ! p,
"H6" ∶ ! q,
--------------------------------------
⊥
using BasicReasoning

  {
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
well_formed (! q) wf_auto2. }
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
Hwf0: well_formed (! q)
Γ Ⱶ
"H0" ∶ ! (! p or ! q) ---> r,
"H2" ∶ p,
"H3" ∶ q,
"H4" ∶ ! ! p ---> ! q,
"H5" ∶ ! ! p,
--------------------------------------
! q
using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
Hwf0: well_formed (! q)
Γ Ⱶ
"H0" ∶ ! (! p or ! q) ---> r,
"H2" ∶ p,
"H3" ∶ q,
"H4" ∶ ! ! p ---> ! q,
"H5" ∶ ! ! p,
"H6" ∶ ! q,
--------------------------------------
⊥
using BasicReasoning

  {
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
Hwf0: well_formed (! q)
Γ Ⱶ
"H0" ∶ ! (! p or ! q) ---> r,
"H2" ∶ p,
"H3" ∶ q,
"H4" ∶ ! ! p ---> ! q,
"H5" ∶ ! ! p,
--------------------------------------
! q
using BasicReasoning

    mlApply "H4".
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
Hwf0: well_formed (! q)
Γ Ⱶ
"H0" ∶ ! (! p or ! q) ---> r,
"H2" ∶ p,
"H3" ∶ q,
"H4" ∶ ! ! p ---> ! q,
"H5" ∶ ! ! p,
--------------------------------------
! ! p
using BasicReasoning
 mlExact "H5".
  }
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
Hwf0: well_formed (! q)
Γ Ⱶ
"H0" ∶ ! (! p or ! q) ---> r,
"H2" ∶ p,
"H3" ∶ q,
"H4" ∶ ! ! p ---> ! q,
"H5" ∶ ! ! p,
"H6" ∶ ! q,
--------------------------------------
⊥
using BasicReasoning

  mlApply "H6".
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
Hwf0: well_formed (! q)
Γ Ⱶ
"H0" ∶ ! (! p or ! q) ---> r,
"H2" ∶ p,
"H3" ∶ q,
"H4" ∶ ! ! p ---> ! q,
"H5" ∶ ! ! p,
"H6" ∶ q ---> ⊥,
--------------------------------------
q
using BasicReasoning
 mlExact "H3".
Defined.

Lemma and_impl' {Σ : Signature} Γ p q r:
  well_formed p ->
  well_formed q ->
  well_formed r ->
  Γ ⊢i ((p ---> (q ---> r)) ---> ((p and q) ---> r)) using BasicReasoning.
Σ: Signature
Γ: Theory
p, q, r: Pattern
well_formed p
→ well_formed q
  → well_formed r
    → Γ ⊢i (p ---> q ---> r) ---> p and q ---> r
      using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
p, q, r: Pattern
well_formed p
→ well_formed q
  → well_formed r
    → Γ ⊢i (p ---> q ---> r) ---> p and q ---> r
      using BasicReasoning
  intros wfp wfq wfr.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Γ ⊢i (p ---> q ---> r) ---> p and q ---> r
using BasicReasoning
  toMLGoal.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
well_formed ((p ---> q ---> r) ---> p and q ---> r)
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Γ Ⱶ
(p ---> q ---> r) ---> p and q ---> r
using BasicReasoning

  {
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
well_formed ((p ---> q ---> r) ---> p and q ---> r) wf_auto2. }
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Γ Ⱶ
(p ---> q ---> r) ---> p and q ---> r
using BasicReasoning

  mlIntro "H0".
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Γ Ⱶ
"H0" ∶ p ---> q ---> r,
--------------------------------------
p and q ---> r
using BasicReasoning
 mlIntro "H1".
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Γ Ⱶ
"H0" ∶ p ---> q ---> r,
"H1" ∶ p and q,
--------------------------------------
r
using BasicReasoning

  mlAssert ("H2" : p).
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
well_formed p
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Γ Ⱶ
"H0" ∶ p ---> q ---> r,
"H1" ∶ p and q,
--------------------------------------
p
using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Γ Ⱶ
"H0" ∶ p ---> q ---> r,
"H1" ∶ p and q,
"H2" ∶ p,
--------------------------------------
r
using BasicReasoning

  {
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
well_formed p wf_auto2. }
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Γ Ⱶ
"H0" ∶ p ---> q ---> r,
"H1" ∶ p and q,
--------------------------------------
p
using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Γ Ⱶ
"H0" ∶ p ---> q ---> r,
"H1" ∶ p and q,
"H2" ∶ p,
--------------------------------------
r
using BasicReasoning

  {
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Γ Ⱶ
"H0" ∶ p ---> q ---> r,
"H1" ∶ p and q,
--------------------------------------
p
using BasicReasoning

    mlAdd (pf_conj_elim_l Γ p q wfp wfq) as "H2".
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Γ Ⱶ
"H2" ∶ p and q ---> p,
"H0" ∶ p ---> q ---> r,
"H1" ∶ p and q,
--------------------------------------
p
using BasicReasoning

    mlApply "H2".
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Γ Ⱶ
"H2" ∶ p and q ---> p,
"H0" ∶ p ---> q ---> r,
"H1" ∶ p and q,
--------------------------------------
p and q
using BasicReasoning

    mlExact "H1".
  }
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Γ Ⱶ
"H0" ∶ p ---> q ---> r,
"H1" ∶ p and q,
"H2" ∶ p,
--------------------------------------
r
using BasicReasoning

  mlAssert ("H3" : q).
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
well_formed q
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
Γ Ⱶ
"H0" ∶ p ---> q ---> r,
"H1" ∶ p and q,
"H2" ∶ p,
--------------------------------------
q
using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
Γ Ⱶ
"H0" ∶ p ---> q ---> r,
"H1" ∶ p and q,
"H2" ∶ p,
"H3" ∶ q,
--------------------------------------
r
using BasicReasoning

  {
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
well_formed q wf_auto2. }
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
Γ Ⱶ
"H0" ∶ p ---> q ---> r,
"H1" ∶ p and q,
"H2" ∶ p,
--------------------------------------
q
using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
Γ Ⱶ
"H0" ∶ p ---> q ---> r,
"H1" ∶ p and q,
"H2" ∶ p,
"H3" ∶ q,
--------------------------------------
r
using BasicReasoning

  {
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
Γ Ⱶ
"H0" ∶ p ---> q ---> r,
"H1" ∶ p and q,
"H2" ∶ p,
--------------------------------------
q
using BasicReasoning

    mlAdd (pf_conj_elim_r Γ p q wfp wfq) as "H4".
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
Γ Ⱶ
"H4" ∶ p and q ---> q,
"H0" ∶ p ---> q ---> r,
"H1" ∶ p and q,
"H2" ∶ p,
--------------------------------------
q
using BasicReasoning

    mlApply "H4".
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
Γ Ⱶ
"H4" ∶ p and q ---> q,
"H0" ∶ p ---> q ---> r,
"H1" ∶ p and q,
"H2" ∶ p,
--------------------------------------
p and q
using BasicReasoning

    mlExact "H1".
  }
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
Γ Ⱶ
"H0" ∶ p ---> q ---> r,
"H1" ∶ p and q,
"H2" ∶ p,
"H3" ∶ q,
--------------------------------------
r
using BasicReasoning

  (* This pattern is basically an "apply ... in" *)
  mlAssert ("H4" : (q ---> r)).
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
well_formed (q ---> r)
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
Hwf1: well_formed (q ---> r)
Γ Ⱶ
"H0" ∶ p ---> q ---> r,
"H1" ∶ p and q,
"H2" ∶ p,
"H3" ∶ q,
--------------------------------------
q ---> r
using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
Hwf1: well_formed (q ---> r)
Γ Ⱶ
"H0" ∶ p ---> q ---> r,
"H1" ∶ p and q,
"H2" ∶ p,
"H3" ∶ q,
"H4" ∶ q ---> r,
--------------------------------------
r
using BasicReasoning

  {
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
well_formed (q ---> r) wf_auto2. }
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
Hwf1: well_formed (q ---> r)
Γ Ⱶ
"H0" ∶ p ---> q ---> r,
"H1" ∶ p and q,
"H2" ∶ p,
"H3" ∶ q,
--------------------------------------
q ---> r
using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
Hwf1: well_formed (q ---> r)
Γ Ⱶ
"H0" ∶ p ---> q ---> r,
"H1" ∶ p and q,
"H2" ∶ p,
"H3" ∶ q,
"H4" ∶ q ---> r,
--------------------------------------
r
using BasicReasoning

  {
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
Hwf1: well_formed (q ---> r)
Γ Ⱶ
"H0" ∶ p ---> q ---> r,
"H1" ∶ p and q,
"H2" ∶ p,
"H3" ∶ q,
--------------------------------------
q ---> r
using BasicReasoning
 mlApply "H0".
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
Hwf1: well_formed (q ---> r)
Γ Ⱶ
"H0" ∶ p ---> q ---> r,
"H1" ∶ p and q,
"H2" ∶ p,
"H3" ∶ q,
--------------------------------------
p
using BasicReasoning
 mlExact "H2". }
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
Hwf1: well_formed (q ---> r)
Γ Ⱶ
"H0" ∶ p ---> q ---> r,
"H1" ∶ p and q,
"H2" ∶ p,
"H3" ∶ q,
"H4" ∶ q ---> r,
--------------------------------------
r
using BasicReasoning

  mlApply "H4".
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
Hwf1: well_formed (q ---> r)
Γ Ⱶ
"H0" ∶ p ---> q ---> r,
"H1" ∶ p and q,
"H2" ∶ p,
"H3" ∶ q,
"H4" ∶ q ---> r,
--------------------------------------
q
using BasicReasoning
 mlExact "H3".
Defined.

Lemma prf_disj_elim_iter {Σ : Signature} Γ l p q r:
  Pattern.wf l ->
  well_formed p ->
  well_formed q ->
  well_formed r ->
  Γ ⊢i ((fold_right patt_imp r (l ++ [p]))
         --->
         ((fold_right patt_imp r (l ++ [q]))
            --->
            (fold_right patt_imp r (l ++ [p or q]))))
  using BasicReasoning.
Σ: Signature
Γ: Theory
l: list Pattern
p, q, r: Pattern
Pattern.wf l
→ well_formed p
  → well_formed q
    → well_formed r
      → Γ
        ⊢i foldr patt_imp r (l ++ [p]) --->
           foldr patt_imp r (l ++ [q]) --->
           foldr patt_imp r (l ++ [p or q])
        using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
l: list Pattern
p, q, r: Pattern
Pattern.wf l
→ well_formed p
  → well_formed q
    → well_formed r
      → Γ
        ⊢i foldr patt_imp r (l ++ [p]) --->
           foldr patt_imp r (l ++ [q]) --->
           foldr patt_imp r (l ++ [p or q])
        using BasicReasoning
  intros wfl wfp wfq wfr.
Σ: Signature
Γ: Theory
l: list Pattern
p, q, r: Pattern
wfl: Pattern.wf l
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Γ
⊢i foldr patt_imp r (l ++ [p]) --->
   foldr patt_imp r (l ++ [q]) --->
   foldr patt_imp r (l ++ [p or q])
using BasicReasoning
  induction l.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfl: Pattern.wf []
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Γ
⊢i foldr patt_imp r ([] ++ [p]) --->
   foldr patt_imp r ([] ++ [q]) --->
   foldr patt_imp r ([] ++ [p or q])
using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfl: Pattern.wf (a :: l)
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Pattern.wf l
→ Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
Γ
⊢i foldr patt_imp r ((a :: l) ++ [p]) --->
   foldr patt_imp r ((a :: l) ++ [q]) --->
   foldr patt_imp r ((a :: l) ++ [p or q])
using BasicReasoning
  -
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfl: Pattern.wf []
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Γ
⊢i foldr patt_imp r ([] ++ [p]) --->
   foldr patt_imp r ([] ++ [q]) --->
   foldr patt_imp r ([] ++ [p or q])
using BasicReasoning simpl.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfl: Pattern.wf []
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r
using BasicReasoning apply prf_disj_elim; wf_auto2.
  -
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfl: Pattern.wf (a :: l)
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Pattern.wf l
→ Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
Γ
⊢i foldr patt_imp r ((a :: l) ++ [p]) --->
   foldr patt_imp r ((a :: l) ++ [q]) --->
   foldr patt_imp r ((a :: l) ++ [p or q])
using BasicReasoning pose proof (wfal := wfl).
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfl: Pattern.wf (a :: l)
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Pattern.wf l
→ Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i foldr patt_imp r ((a :: l) ++ [p]) --->
   foldr patt_imp r ((a :: l) ++ [q]) --->
   foldr patt_imp r ((a :: l) ++ [p or q])
using BasicReasoning
    unfold Pattern.wf in wfl.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfl: foldr andb true (map well_formed (a :: l))
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Pattern.wf l
→ Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i foldr patt_imp r ((a :: l) ++ [p]) --->
   foldr patt_imp r ((a :: l) ++ [q]) --->
   foldr patt_imp r ((a :: l) ++ [p or q])
using BasicReasoning simpl in wfl.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfl: well_formed a && foldr andb true (map well_formed l)
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Pattern.wf l
→ Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i foldr patt_imp r ((a :: l) ++ [p]) --->
   foldr patt_imp r ((a :: l) ++ [q]) --->
   foldr patt_imp r ((a :: l) ++ [p or q])
using BasicReasoning apply andb_prop in wfl.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfl: well_formed a = true ∧ foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Pattern.wf l
→ Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i foldr patt_imp r ((a :: l) ++ [p]) --->
   foldr patt_imp r ((a :: l) ++ [q]) --->
   foldr patt_imp r ((a :: l) ++ [p or q])
using BasicReasoning destruct wfl as [wfa wfl].
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Pattern.wf l
→ Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i foldr patt_imp r ((a :: l) ++ [p]) --->
   foldr patt_imp r ((a :: l) ++ [q]) --->
   foldr patt_imp r ((a :: l) ++ [p or q])
using BasicReasoning
    specialize (IHl wfl).
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i foldr patt_imp r ((a :: l) ++ [p]) --->
   foldr patt_imp r ((a :: l) ++ [q]) --->
   foldr patt_imp r ((a :: l) ++ [p or q])
using BasicReasoning
    simpl in *.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ
⊢i (a ---> foldr patt_imp r (l ++ [p])) --->
   (a ---> foldr patt_imp r (l ++ [q])) --->
   a ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
    toMLGoal.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
well_formed
  ((a ---> foldr patt_imp r (l ++ [p])) --->
   (a ---> foldr patt_imp r (l ++ [q])) --->
   a ---> foldr patt_imp r (l ++ [p or q]))
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
   foldr patt_imp r (l ++ [q]) --->
   foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ Ⱶ
(a ---> foldr patt_imp r (l ++ [p])) --->
(a ---> foldr patt_imp r (l ++ [q])) --->
a ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning

    {
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
well_formed
  ((a ---> foldr patt_imp r (l ++ [p])) --->
   (a ---> foldr patt_imp r (l ++ [q])) --->
   a ---> foldr patt_imp r (l ++ [p or q])) wf_auto2. }
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ Ⱶ
(a ---> foldr patt_imp r (l ++ [p])) --->
(a ---> foldr patt_imp r (l ++ [q])) --->
a ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning

    mlIntro "H0".
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ Ⱶ
"H0" ∶ a ---> foldr patt_imp r (l ++ [p]),
--------------------------------------
(a ---> foldr patt_imp r (l ++ [q])) --->
a ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
 mlIntro "H1".
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ Ⱶ
"H0" ∶ a ---> foldr patt_imp r (l ++ [p]),
"H1" ∶ a ---> foldr patt_imp r (l ++ [q]),
--------------------------------------
a ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
 mlIntro "H2".
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ Ⱶ
"H0" ∶ a ---> foldr patt_imp r (l ++ [p]),
"H1" ∶ a ---> foldr patt_imp r (l ++ [q]),
"H2" ∶ a,
--------------------------------------
foldr patt_imp r (l ++ [p or q])
using BasicReasoning
 
    mlAdd IHl as "H3".
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ Ⱶ
"H3" ∶ foldr patt_imp r (l ++ [p]) --->
       foldr patt_imp r (l ++ [q]) --->
       foldr patt_imp r (l ++ [p or q]),
"H0" ∶ a ---> foldr patt_imp r (l ++ [p]),
"H1" ∶ a ---> foldr patt_imp r (l ++ [q]),
"H2" ∶ a,
--------------------------------------
foldr patt_imp r (l ++ [p or q])
using BasicReasoning

    mlAssert ("H4" : (foldr patt_imp r (l ++ [p]))).
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
well_formed (foldr patt_imp r (l ++ [p]))
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
   foldr patt_imp r (l ++ [q]) --->
   foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Γ Ⱶ
"H3" ∶ foldr patt_imp r (l ++ [p]) --->
       foldr patt_imp r (l ++ [q]) --->
       foldr patt_imp r (l ++ [p or q]),
"H0" ∶ a ---> foldr patt_imp r (l ++ [p]),
"H1" ∶ a ---> foldr patt_imp r (l ++ [q]),
"H2" ∶ a,
--------------------------------------
foldr patt_imp r (l ++ [p])
using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
   foldr patt_imp r (l ++ [q]) --->
   foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Γ Ⱶ
"H3" ∶ foldr patt_imp r (l ++ [p]) --->
       foldr patt_imp r (l ++ [q]) --->
       foldr patt_imp r (l ++ [p or q]),
"H0" ∶ a ---> foldr patt_imp r (l ++ [p]),
"H1" ∶ a ---> foldr patt_imp r (l ++ [q]),
"H2" ∶ a,
"H4" ∶ foldr patt_imp r (l ++ [p]),
--------------------------------------
foldr patt_imp r (l ++ [p or q])
using BasicReasoning

    {
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
well_formed (foldr patt_imp r (l ++ [p])) wf_auto2. }
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Γ Ⱶ
"H3" ∶ foldr patt_imp r (l ++ [p]) --->
       foldr patt_imp r (l ++ [q]) --->
       foldr patt_imp r (l ++ [p or q]),
"H0" ∶ a ---> foldr patt_imp r (l ++ [p]),
"H1" ∶ a ---> foldr patt_imp r (l ++ [q]),
"H2" ∶ a,
--------------------------------------
foldr patt_imp r (l ++ [p])
using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
   foldr patt_imp r (l ++ [q]) --->
   foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Γ Ⱶ
"H3" ∶ foldr patt_imp r (l ++ [p]) --->
       foldr patt_imp r (l ++ [q]) --->
       foldr patt_imp r (l ++ [p or q]),
"H0" ∶ a ---> foldr patt_imp r (l ++ [p]),
"H1" ∶ a ---> foldr patt_imp r (l ++ [q]),
"H2" ∶ a,
"H4" ∶ foldr patt_imp r (l ++ [p]),
--------------------------------------
foldr patt_imp r (l ++ [p or q])
using BasicReasoning

    {
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Γ Ⱶ
"H3" ∶ foldr patt_imp r (l ++ [p]) --->
       foldr patt_imp r (l ++ [q]) --->
       foldr patt_imp r (l ++ [p or q]),
"H0" ∶ a ---> foldr patt_imp r (l ++ [p]),
"H1" ∶ a ---> foldr patt_imp r (l ++ [q]),
"H2" ∶ a,
--------------------------------------
foldr patt_imp r (l ++ [p])
using BasicReasoning
 mlApply "H0".
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Γ Ⱶ
"H3" ∶ foldr patt_imp r (l ++ [p]) --->
       foldr patt_imp r (l ++ [q]) --->
       foldr patt_imp r (l ++ [p or q]),
"H0" ∶ a ---> foldr patt_imp r (l ++ [p]),
"H1" ∶ a ---> foldr patt_imp r (l ++ [q]),
"H2" ∶ a,
--------------------------------------
a
using BasicReasoning
 mlExact "H2". }
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Γ Ⱶ
"H3" ∶ foldr patt_imp r (l ++ [p]) --->
       foldr patt_imp r (l ++ [q]) --->
       foldr patt_imp r (l ++ [p or q]),
"H0" ∶ a ---> foldr patt_imp r (l ++ [p]),
"H1" ∶ a ---> foldr patt_imp r (l ++ [q]),
"H2" ∶ a,
"H4" ∶ foldr patt_imp r (l ++ [p]),
--------------------------------------
foldr patt_imp r (l ++ [p or q])
using BasicReasoning

    mlAssert ("H5" : (foldr patt_imp r (l ++ [q]))).
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
well_formed (foldr patt_imp r (l ++ [q]))
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
   foldr patt_imp r (l ++ [q]) --->
   foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
Γ Ⱶ
"H3" ∶ foldr patt_imp r (l ++ [p]) --->
       foldr patt_imp r (l ++ [q]) --->
       foldr patt_imp r (l ++ [p or q]),
"H0" ∶ a ---> foldr patt_imp r (l ++ [p]),
"H1" ∶ a ---> foldr patt_imp r (l ++ [q]),
"H2" ∶ a,
"H4" ∶ foldr patt_imp r (l ++ [p]),
--------------------------------------
foldr patt_imp r (l ++ [q])
using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
   foldr patt_imp r (l ++ [q]) --->
   foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
Γ Ⱶ
"H3" ∶ foldr patt_imp r (l ++ [p]) --->
       foldr patt_imp r (l ++ [q]) --->
       foldr patt_imp r (l ++ [p or q]),
"H0" ∶ a ---> foldr patt_imp r (l ++ [p]),
"H1" ∶ a ---> foldr patt_imp r (l ++ [q]),
"H2" ∶ a,
"H4" ∶ foldr patt_imp r (l ++ [p]),
"H5" ∶ foldr patt_imp r (l ++ [q]),
--------------------------------------
foldr patt_imp r (l ++ [p or q])
using BasicReasoning

    {
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
well_formed (foldr patt_imp r (l ++ [q])) wf_auto2. }
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
Γ Ⱶ
"H3" ∶ foldr patt_imp r (l ++ [p]) --->
       foldr patt_imp r (l ++ [q]) --->
       foldr patt_imp r (l ++ [p or q]),
"H0" ∶ a ---> foldr patt_imp r (l ++ [p]),
"H1" ∶ a ---> foldr patt_imp r (l ++ [q]),
"H2" ∶ a,
"H4" ∶ foldr patt_imp r (l ++ [p]),
--------------------------------------
foldr patt_imp r (l ++ [q])
using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
   foldr patt_imp r (l ++ [q]) --->
   foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
Γ Ⱶ
"H3" ∶ foldr patt_imp r (l ++ [p]) --->
       foldr patt_imp r (l ++ [q]) --->
       foldr patt_imp r (l ++ [p or q]),
"H0" ∶ a ---> foldr patt_imp r (l ++ [p]),
"H1" ∶ a ---> foldr patt_imp r (l ++ [q]),
"H2" ∶ a,
"H4" ∶ foldr patt_imp r (l ++ [p]),
"H5" ∶ foldr patt_imp r (l ++ [q]),
--------------------------------------
foldr patt_imp r (l ++ [p or q])
using BasicReasoning

    {
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
Γ Ⱶ
"H3" ∶ foldr patt_imp r (l ++ [p]) --->
       foldr patt_imp r (l ++ [q]) --->
       foldr patt_imp r (l ++ [p or q]),
"H0" ∶ a ---> foldr patt_imp r (l ++ [p]),
"H1" ∶ a ---> foldr patt_imp r (l ++ [q]),
"H2" ∶ a,
"H4" ∶ foldr patt_imp r (l ++ [p]),
--------------------------------------
foldr patt_imp r (l ++ [q])
using BasicReasoning
 mlApply "H1".
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
Γ Ⱶ
"H3" ∶ foldr patt_imp r (l ++ [p]) --->
       foldr patt_imp r (l ++ [q]) --->
       foldr patt_imp r (l ++ [p or q]),
"H0" ∶ a ---> foldr patt_imp r (l ++ [p]),
"H1" ∶ a ---> foldr patt_imp r (l ++ [q]),
"H2" ∶ a,
"H4" ∶ foldr patt_imp r (l ++ [p]),
--------------------------------------
a
using BasicReasoning
 mlExact "H2". }
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
Γ Ⱶ
"H3" ∶ foldr patt_imp r (l ++ [p]) --->
       foldr patt_imp r (l ++ [q]) --->
       foldr patt_imp r (l ++ [p or q]),
"H0" ∶ a ---> foldr patt_imp r (l ++ [p]),
"H1" ∶ a ---> foldr patt_imp r (l ++ [q]),
"H2" ∶ a,
"H4" ∶ foldr patt_imp r (l ++ [p]),
"H5" ∶ foldr patt_imp r (l ++ [q]),
--------------------------------------
foldr patt_imp r (l ++ [p or q])
using BasicReasoning

    mlAssert ("H6" : (foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]))).
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
well_formed
  (foldr patt_imp r (l ++ [q]) --->
   foldr patt_imp r (l ++ [p or q]))
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
   foldr patt_imp r (l ++ [q]) --->
   foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
Hwf1: well_formed
  (foldr patt_imp r (l ++ [q]) --->
   foldr patt_imp r (l ++ [p or q]))
Γ Ⱶ
"H3" ∶ foldr patt_imp r (l ++ [p]) --->
       foldr patt_imp r (l ++ [q]) --->
       foldr patt_imp r (l ++ [p or q]),
"H0" ∶ a ---> foldr patt_imp r (l ++ [p]),
"H1" ∶ a ---> foldr patt_imp r (l ++ [q]),
"H2" ∶ a,
"H4" ∶ foldr patt_imp r (l ++ [p]),
"H5" ∶ foldr patt_imp r (l ++ [q]),
--------------------------------------
foldr patt_imp r (l ++ [q]) --->
foldr patt_imp r (l ++ [p or q])
using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
   foldr patt_imp r (l ++ [q]) --->
   foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
Hwf1: well_formed
  (foldr patt_imp r (l ++ [q]) --->
   foldr patt_imp r (l ++ [p or q]))
Γ Ⱶ
"H3" ∶ foldr patt_imp r (l ++ [p]) --->
       foldr patt_imp r (l ++ [q]) --->
       foldr patt_imp r (l ++ [p or q]),
"H0" ∶ a ---> foldr patt_imp r (l ++ [p]),
"H1" ∶ a ---> foldr patt_imp r (l ++ [q]),
"H2" ∶ a,
"H4" ∶ foldr patt_imp r (l ++ [p]),
"H5" ∶ foldr patt_imp r (l ++ [q]),
"H6" ∶ foldr patt_imp r (l ++ [q]) --->
       foldr patt_imp r (l ++ [p or q]),
--------------------------------------
foldr patt_imp r (l ++ [p or q])
using BasicReasoning

    {
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
well_formed
  (foldr patt_imp r (l ++ [q]) --->
   foldr patt_imp r (l ++ [p or q])) wf_auto2. }
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
Hwf1: well_formed
  (foldr patt_imp r (l ++ [q]) --->
   foldr patt_imp r (l ++ [p or q]))
Γ Ⱶ
"H3" ∶ foldr patt_imp r (l ++ [p]) --->
       foldr patt_imp r (l ++ [q]) --->
       foldr patt_imp r (l ++ [p or q]),
"H0" ∶ a ---> foldr patt_imp r (l ++ [p]),
"H1" ∶ a ---> foldr patt_imp r (l ++ [q]),
"H2" ∶ a,
"H4" ∶ foldr patt_imp r (l ++ [p]),
"H5" ∶ foldr patt_imp r (l ++ [q]),
--------------------------------------
foldr patt_imp r (l ++ [q]) --->
foldr patt_imp r (l ++ [p or q])
using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
   foldr patt_imp r (l ++ [q]) --->
   foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
Hwf1: well_formed
  (foldr patt_imp r (l ++ [q]) --->
   foldr patt_imp r (l ++ [p or q]))
Γ Ⱶ
"H3" ∶ foldr patt_imp r (l ++ [p]) --->
       foldr patt_imp r (l ++ [q]) --->
       foldr patt_imp r (l ++ [p or q]),
"H0" ∶ a ---> foldr patt_imp r (l ++ [p]),
"H1" ∶ a ---> foldr patt_imp r (l ++ [q]),
"H2" ∶ a,
"H4" ∶ foldr patt_imp r (l ++ [p]),
"H5" ∶ foldr patt_imp r (l ++ [q]),
"H6" ∶ foldr patt_imp r (l ++ [q]) --->
       foldr patt_imp r (l ++ [p or q]),
--------------------------------------
foldr patt_imp r (l ++ [p or q])
using BasicReasoning

    {
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
Hwf1: well_formed
  (foldr patt_imp r (l ++ [q]) --->
   foldr patt_imp r (l ++ [p or q]))
Γ Ⱶ
"H3" ∶ foldr patt_imp r (l ++ [p]) --->
       foldr patt_imp r (l ++ [q]) --->
       foldr patt_imp r (l ++ [p or q]),
"H0" ∶ a ---> foldr patt_imp r (l ++ [p]),
"H1" ∶ a ---> foldr patt_imp r (l ++ [q]),
"H2" ∶ a,
"H4" ∶ foldr patt_imp r (l ++ [p]),
"H5" ∶ foldr patt_imp r (l ++ [q]),
--------------------------------------
foldr patt_imp r (l ++ [q]) --->
foldr patt_imp r (l ++ [p or q])
using BasicReasoning
 mlApply "H3".
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
Hwf1: well_formed
  (foldr patt_imp r (l ++ [q]) --->
   foldr patt_imp r (l ++ [p or q]))
Γ Ⱶ
"H3" ∶ foldr patt_imp r (l ++ [p]) --->
       foldr patt_imp r (l ++ [q]) --->
       foldr patt_imp r (l ++ [p or q]),
"H0" ∶ a ---> foldr patt_imp r (l ++ [p]),
"H1" ∶ a ---> foldr patt_imp r (l ++ [q]),
"H2" ∶ a,
"H4" ∶ foldr patt_imp r (l ++ [p]),
"H5" ∶ foldr patt_imp r (l ++ [q]),
--------------------------------------
foldr patt_imp r (l ++ [p])
using BasicReasoning
 mlExact "H4". }
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
Hwf1: well_formed
  (foldr patt_imp r (l ++ [q]) --->
   foldr patt_imp r (l ++ [p or q]))
Γ Ⱶ
"H3" ∶ foldr patt_imp r (l ++ [p]) --->
       foldr patt_imp r (l ++ [q]) --->
       foldr patt_imp r (l ++ [p or q]),
"H0" ∶ a ---> foldr patt_imp r (l ++ [p]),
"H1" ∶ a ---> foldr patt_imp r (l ++ [q]),
"H2" ∶ a,
"H4" ∶ foldr patt_imp r (l ++ [p]),
"H5" ∶ foldr patt_imp r (l ++ [q]),
"H6" ∶ foldr patt_imp r (l ++ [q]) --->
       foldr patt_imp r (l ++ [p or q]),
--------------------------------------
foldr patt_imp r (l ++ [p or q])
using BasicReasoning

    mlApply "H6".
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ
⊢i foldr patt_imp r (l ++ [p]) --->
foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q])
using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
Hwf1: well_formed
  (foldr patt_imp r (l ++ [q]) --->
   foldr patt_imp r (l ++ [p or q]))
Γ Ⱶ
"H3" ∶ foldr patt_imp r (l ++ [p]) --->
       foldr patt_imp r (l ++ [q]) --->
       foldr patt_imp r (l ++ [p or q]),
"H0" ∶ a ---> foldr patt_imp r (l ++ [p]),
"H1" ∶ a ---> foldr patt_imp r (l ++ [q]),
"H2" ∶ a,
"H4" ∶ foldr patt_imp r (l ++ [p]),
"H5" ∶ foldr patt_imp r (l ++ [q]),
"H6" ∶ foldr patt_imp r (l ++ [q]) --->
       foldr patt_imp r (l ++ [p or q]),
--------------------------------------
foldr patt_imp r (l ++ [q])
using BasicReasoning

    mlExact "H5".
Defined.

Lemma prf_disj_elim_iter_2 {Σ : Signature} Γ l₁ l₂ p q r:
  Pattern.wf l₁ ->
  Pattern.wf l₂ ->
  well_formed p ->
  well_formed q ->
  well_formed r ->
  Γ ⊢i ((fold_right patt_imp r (l₁ ++ [p] ++ l₂))
         --->
         ((fold_right patt_imp r (l₁ ++ [q] ++ l₂))
            --->
            (fold_right patt_imp r (l₁ ++ [p or q] ++ l₂))))
  using BasicReasoning.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
Pattern.wf l₁
→ Pattern.wf l₂
  → well_formed p
    → well_formed q
      → well_formed r
        → Γ
          ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
             foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
             foldr patt_imp r (l₁ ++ [p or q] ++ l₂)
          using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
Pattern.wf l₁
→ Pattern.wf l₂
  → well_formed p
    → well_formed q
      → well_formed r
        → Γ
          ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
             foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
             foldr patt_imp r (l₁ ++ [p or q] ++ l₂)
          using BasicReasoning
  intros wfl₁ wfl₂ wfp wfq wfr.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
wfl₁: Pattern.wf l₁
wfl₂: Pattern.wf l₂
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Γ
⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
   foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
   foldr patt_imp r (l₁ ++ [p or q] ++ l₂)
using BasicReasoning
  move: l₁ wfl₁.
Σ: Signature
Γ: Theory
l₂: list Pattern
p, q, r: Pattern
wfl₂: Pattern.wf l₂
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
∀ l₁ : list Pattern,
  Pattern.wf l₁
  → Γ
    ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
       foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
       foldr patt_imp r (l₁ ++ [p or q] ++ l₂)
    using BasicReasoning
  induction l₂; intros l₁ wfl₁.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfl₂: Pattern.wf []
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
l₁: list Pattern
wfl₁: Pattern.wf l₁
Γ
⊢i foldr patt_imp r (l₁ ++ [p] ++ []) --->
   foldr patt_imp r (l₁ ++ [q] ++ []) --->
   foldr patt_imp r (l₁ ++ [p or q] ++ [])
using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfl₂: Pattern.wf (a :: l₂)
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
Γ
⊢i foldr patt_imp r (l₁ ++ [p] ++ a :: l₂) --->
   foldr patt_imp r (l₁ ++ [q] ++ a :: l₂) --->
   foldr patt_imp r (l₁ ++ [p or q] ++ a :: l₂)
using BasicReasoning
  -
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfl₂: Pattern.wf []
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
l₁: list Pattern
wfl₁: Pattern.wf l₁
Γ
⊢i foldr patt_imp r (l₁ ++ [p] ++ []) --->
   foldr patt_imp r (l₁ ++ [q] ++ []) --->
   foldr patt_imp r (l₁ ++ [p or q] ++ [])
using BasicReasoning simpl.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfl₂: Pattern.wf []
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
l₁: list Pattern
wfl₁: Pattern.wf l₁
Γ
⊢i foldr patt_imp r (l₁ ++ [p]) --->
   foldr patt_imp r (l₁ ++ [q]) --->
   foldr patt_imp r (l₁ ++ [p or q])
using BasicReasoning apply prf_disj_elim_iter; wf_auto2.
  -
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfl₂: Pattern.wf (a :: l₂)
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
Γ
⊢i foldr patt_imp r (l₁ ++ [p] ++ a :: l₂) --->
   foldr patt_imp r (l₁ ++ [q] ++ a :: l₂) --->
   foldr patt_imp r (l₁ ++ [p or q] ++ a :: l₂)
using BasicReasoning pose proof (wfal₂ := wfl₂).
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfl₂: Pattern.wf (a :: l₂)
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
Γ
⊢i foldr patt_imp r (l₁ ++ [p] ++ a :: l₂) --->
   foldr patt_imp r (l₁ ++ [q] ++ a :: l₂) --->
   foldr patt_imp r (l₁ ++ [p or q] ++ a :: l₂)
using BasicReasoning
    unfold Pattern.wf in wfl₂.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfl₂: foldr andb true (map well_formed (a :: l₂))
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
Γ
⊢i foldr patt_imp r (l₁ ++ [p] ++ a :: l₂) --->
   foldr patt_imp r (l₁ ++ [q] ++ a :: l₂) --->
   foldr patt_imp r (l₁ ++ [p or q] ++ a :: l₂)
using BasicReasoning simpl in wfl₂.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfl₂: well_formed a &&
foldr andb true (map well_formed l₂)
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
Γ
⊢i foldr patt_imp r (l₁ ++ [p] ++ a :: l₂) --->
   foldr patt_imp r (l₁ ++ [q] ++ a :: l₂) --->
   foldr patt_imp r (l₁ ++ [p or q] ++ a :: l₂)
using BasicReasoning apply andb_prop in wfl₂.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfl₂: well_formed a = true
∧ foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
Γ
⊢i foldr patt_imp r (l₁ ++ [p] ++ a :: l₂) --->
   foldr patt_imp r (l₁ ++ [q] ++ a :: l₂) --->
   foldr patt_imp r (l₁ ++ [p or q] ++ a :: l₂)
using BasicReasoning destruct wfl₂ as [wfa wfl₂].
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
Γ
⊢i foldr patt_imp r (l₁ ++ [p] ++ a :: l₂) --->
   foldr patt_imp r (l₁ ++ [q] ++ a :: l₂) --->
   foldr patt_imp r (l₁ ++ [p or q] ++ a :: l₂)
using BasicReasoning

    simpl. (* We need to move 'a' to the beginning of l₁; then we can apply IHl₂. *)
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
Γ
⊢i foldr patt_imp r (l₁ ++ p :: a :: l₂) --->
   foldr patt_imp r (l₁ ++ q :: a :: l₂) --->
   foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
using BasicReasoning
    (* Or we can swap p and a (move a to the end of l_1) *)
    remember (foldr patt_imp r (l₁ ++ p :: a :: l₂)) as A in |-.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
Γ
⊢i foldr patt_imp r (l₁ ++ p :: a :: l₂) --->
   foldr patt_imp r (l₁ ++ q :: a :: l₂) --->
   foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
using BasicReasoning
    remember (foldr patt_imp r (l₁ ++ q :: a :: l₂)) as B in |-.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
Γ
⊢i foldr patt_imp r (l₁ ++ p :: a :: l₂) --->
   foldr patt_imp r (l₁ ++ q :: a :: l₂) --->
   foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
using BasicReasoning
    remember (foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)) as C in |-.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ
⊢i foldr patt_imp r (l₁ ++ p :: a :: l₂) --->
   foldr patt_imp r (l₁ ++ q :: a :: l₂) --->
   foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
using BasicReasoning
    eapply cast_proof'.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
(foldr patt_imp r (l₁ ++ p :: a :: l₂) --->
 foldr patt_imp r (l₁ ++ q :: a :: l₂) --->
 foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)) = ?ϕ
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ ⊢i ?ϕ using BasicReasoning
    {
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
(foldr patt_imp r (l₁ ++ p :: a :: l₂) --->
 foldr patt_imp r (l₁ ++ q :: a :: l₂) --->
 foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)) = ?ϕ rewrite -HeqA.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
(A --->
 foldr patt_imp r (l₁ ++ q :: a :: l₂) --->
 foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)) = ?ϕ rewrite -HeqB.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
(A --->
 B ---> foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)) =
?ϕ rewrite -HeqC.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
(A ---> B ---> C) = ?ϕ reflexivity. }
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ ⊢i A ---> B ---> C using BasicReasoning
    eapply cast_proof'.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
(A ---> B ---> C) = ?ϕ
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ ⊢i ?ϕ using BasicReasoning
    {
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
(A ---> B ---> C) = ?ϕ
      rewrite -> tofold at 1.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
foldr patt_imp (A ---> B ---> C) [] = ?ϕ rewrite consume.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
foldr patt_imp (B ---> C) ([] ++ [A]) = ?ϕ rewrite consume.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
foldr patt_imp C (([] ++ [A]) ++ [B]) = ?ϕ rewrite [_ ++ [B] ]/=.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
foldr patt_imp C [A; B] = ?ϕ
      rewrite -> HeqA at 1.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
foldr patt_imp C
  [foldr patt_imp r (l₁ ++ p :: a :: l₂); B] = ?ϕ rewrite -> HeqB at 1.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
foldr patt_imp C
  [foldr patt_imp r (l₁ ++ p :: a :: l₂);
   foldr patt_imp r (l₁ ++ q :: a :: l₂)] = ?ϕ rewrite -> HeqC at 1.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
foldr patt_imp
  (foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂))
  [foldr patt_imp r (l₁ ++ p :: a :: l₂);
   foldr patt_imp r (l₁ ++ q :: a :: l₂)] = ?ϕ
      reflexivity.
    }
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ
⊢i foldr patt_imp
     (foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂))
     [foldr patt_imp r (l₁ ++ p :: a :: l₂);
      foldr patt_imp r (l₁ ++ q :: a :: l₂)]
using BasicReasoning
    eapply prf_weaken_conclusion_iter_meta_meta.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Pattern.wf
  [foldr patt_imp r (l₁ ++ p :: a :: l₂);
   foldr patt_imp r (l₁ ++ q :: a :: l₂)]
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed ?g
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed
  (foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ
⊢i ?g --->
   foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ
⊢i foldr patt_imp ?g
     [foldr patt_imp r (l₁ ++ p :: a :: l₂);
      foldr patt_imp r (l₁ ++ q :: a :: l₂)]
using BasicReasoning
    4: {
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ
⊢i ?g --->
   foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
using BasicReasoning
      eapply cast_proof'.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
(?g ---> foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)) =
?ϕ
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ ⊢i ?ϕ using BasicReasoning
      {
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
(?g ---> foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)) =
?ϕ
        replace (l₁ ++ (p or q) :: a :: l₂) with (l₁ ++ [p or q; a] ++ l₂) by reflexivity.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
(?g ---> foldr patt_imp r (l₁ ++ [p or q; a] ++ l₂)) =
?ϕ
        reflexivity.
      }
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ
⊢i ?g ---> foldr patt_imp r (l₁ ++ [p or q; a] ++ l₂)
using BasicReasoning
      apply prf_reorder_iter; wf_auto2.
    }
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Pattern.wf
  [foldr patt_imp r (l₁ ++ p :: a :: l₂);
   foldr patt_imp r (l₁ ++ q :: a :: l₂)]
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed
  (foldr patt_imp r (l₁ ++ [a; p or q] ++ l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed
  (foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ
⊢i foldr patt_imp
     (foldr patt_imp r (l₁ ++ [a; p or q] ++ l₂))
     [foldr patt_imp r (l₁ ++ p :: a :: l₂);
      foldr patt_imp r (l₁ ++ q :: a :: l₂)]
using BasicReasoning
    all: try_wfauto2.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ
⊢i foldr patt_imp
     (foldr patt_imp r (l₁ ++ [a; p or q] ++ l₂))
     [foldr patt_imp r (l₁ ++ p :: a :: l₂);
      foldr patt_imp r (l₁ ++ q :: a :: l₂)]
using BasicReasoning
    simpl.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ
⊢i foldr patt_imp r (l₁ ++ p :: a :: l₂) --->
   foldr patt_imp r (l₁ ++ q :: a :: l₂) --->
   foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)
using BasicReasoning

    eapply cast_proof'.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
(foldr patt_imp r (l₁ ++ p :: a :: l₂) --->
 foldr patt_imp r (l₁ ++ q :: a :: l₂) --->
 foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) = ?ϕ
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ ⊢i ?ϕ using BasicReasoning
    {
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
(foldr patt_imp r (l₁ ++ p :: a :: l₂) --->
 foldr patt_imp r (l₁ ++ q :: a :: l₂) --->
 foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) = ?ϕ 
      rewrite -> tofold at 1.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
foldr patt_imp
  (foldr patt_imp r (l₁ ++ p :: a :: l₂) --->
   foldr patt_imp r (l₁ ++ q :: a :: l₂) --->
   foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) [] =
?ϕ repeat rewrite consume.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
foldr patt_imp
  (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂))
  (([] ++ [foldr patt_imp r (l₁ ++ p :: a :: l₂)]) ++
   [foldr patt_imp r (l₁ ++ q :: a :: l₂)]) = ?ϕ rewrite [_ ++ [_] ]/=.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
foldr patt_imp
  (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂))
  [foldr patt_imp r (l₁ ++ p :: a :: l₂);
   foldr patt_imp r (l₁ ++ q :: a :: l₂)] = ?ϕ

    replace
      ([foldr patt_imp r (l₁ ++ p :: a :: l₂); foldr patt_imp r (l₁ ++ q :: a :: l₂)])
      with
        ([foldr patt_imp r (l₁ ++ p :: a :: l₂)] ++ (foldr patt_imp r (l₁ ++ q :: a :: l₂))::[])
      by reflexivity.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
foldr patt_imp
  (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂))
  ([foldr patt_imp r (l₁ ++ p :: a :: l₂)] ++
   [foldr patt_imp r (l₁ ++ q :: a :: l₂)]) = ?ϕ
      reflexivity.
    }
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ
⊢i foldr patt_imp
     (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂))
     ([foldr patt_imp r (l₁ ++ p :: a :: l₂)] ++
      [foldr patt_imp r (l₁ ++ q :: a :: l₂)])
using BasicReasoning

    eapply prf_strenghten_premise_iter_meta_meta with (h := foldr patt_imp r (l₁ ++ a :: q :: l₂)).
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Pattern.wf [foldr patt_imp r (l₁ ++ p :: a :: l₂)]
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Pattern.wf []
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed (foldr patt_imp r (l₁ ++ a :: q :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed (foldr patt_imp r (l₁ ++ q :: a :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed
  (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ
⊢i foldr patt_imp r (l₁ ++ q :: a :: l₂) --->
   foldr patt_imp r (l₁ ++ a :: q :: l₂)
using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ
⊢i foldr patt_imp
     (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂))
     ([foldr patt_imp r (l₁ ++ p :: a :: l₂)] ++
      [foldr patt_imp r (l₁ ++ a :: q :: l₂)])
using BasicReasoning
    6: {
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ
⊢i foldr patt_imp r (l₁ ++ q :: a :: l₂) --->
   foldr patt_imp r (l₁ ++ a :: q :: l₂)
using BasicReasoning apply prf_reorder_iter; wf_auto2. }
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Pattern.wf [foldr patt_imp r (l₁ ++ p :: a :: l₂)]
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Pattern.wf []
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed (foldr patt_imp r (l₁ ++ a :: q :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed (foldr patt_imp r (l₁ ++ q :: a :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed
  (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ
⊢i foldr patt_imp
     (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂))
     ([foldr patt_imp r (l₁ ++ p :: a :: l₂)] ++
      [foldr patt_imp r (l₁ ++ a :: q :: l₂)])
using BasicReasoning
    all: try_wfauto2.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ
⊢i foldr patt_imp
     (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂))
     ([foldr patt_imp r (l₁ ++ p :: a :: l₂)] ++
      [foldr patt_imp r (l₁ ++ a :: q :: l₂)])
using BasicReasoning

    eapply cast_proof'.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
foldr patt_imp
  (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂))
  ([foldr patt_imp r (l₁ ++ p :: a :: l₂)] ++
   [foldr patt_imp r (l₁ ++ a :: q :: l₂)]) = ?ϕ
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ ⊢i ?ϕ using BasicReasoning
    {
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
foldr patt_imp
  (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂))
  ([foldr patt_imp r (l₁ ++ p :: a :: l₂)] ++
   [foldr patt_imp r (l₁ ++ a :: q :: l₂)]) = ?ϕ
      replace
        ([foldr patt_imp r (l₁ ++ p :: a :: l₂)] ++ [foldr patt_imp r (l₁ ++ a :: q :: l₂)])
        with
        ([] ++ ((foldr patt_imp r (l₁ ++ p :: a :: l₂))::[foldr patt_imp r (l₁ ++ a :: q :: l₂)]))
        by reflexivity.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
foldr patt_imp
  (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂))
  ([] ++
   [foldr patt_imp r (l₁ ++ p :: a :: l₂);
    foldr patt_imp r (l₁ ++ a :: q :: l₂)]) = ?ϕ
      reflexivity.
   }
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ
⊢i foldr patt_imp
     (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂))
     ([] ++
      [foldr patt_imp r (l₁ ++ p :: a :: l₂);
       foldr patt_imp r (l₁ ++ a :: q :: l₂)])
using BasicReasoning

    eapply prf_strenghten_premise_iter_meta_meta with (h := (foldr patt_imp r (l₁ ++ a :: p :: l₂))).
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Pattern.wf []
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Pattern.wf [foldr patt_imp r (l₁ ++ a :: q :: l₂)]
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed (foldr patt_imp r (l₁ ++ a :: p :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed (foldr patt_imp r (l₁ ++ p :: a :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed
  (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ
⊢i foldr patt_imp r (l₁ ++ p :: a :: l₂) --->
   foldr patt_imp r (l₁ ++ a :: p :: l₂)
using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ
⊢i foldr patt_imp
     (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂))
     ([] ++
      [foldr patt_imp r (l₁ ++ a :: p :: l₂);
       foldr patt_imp r (l₁ ++ a :: q :: l₂)])
using BasicReasoning
    6: {
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ
⊢i foldr patt_imp r (l₁ ++ p :: a :: l₂) --->
   foldr patt_imp r (l₁ ++ a :: p :: l₂)
using BasicReasoning  apply prf_reorder_iter; wf_auto2. }
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Pattern.wf []
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Pattern.wf [foldr patt_imp r (l₁ ++ a :: q :: l₂)]
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed (foldr patt_imp r (l₁ ++ a :: p :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed (foldr patt_imp r (l₁ ++ p :: a :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed
  (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ
⊢i foldr patt_imp
     (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂))
     ([] ++
      [foldr patt_imp r (l₁ ++ a :: p :: l₂);
       foldr patt_imp r (l₁ ++ a :: q :: l₂)])
using BasicReasoning
    all: try_wfauto2.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ
⊢i foldr patt_imp
     (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂))
     ([] ++
      [foldr patt_imp r (l₁ ++ a :: p :: l₂);
       foldr patt_imp r (l₁ ++ a :: q :: l₂)])
using BasicReasoning

    simpl.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ
⊢i foldr patt_imp r (l₁ ++ a :: p :: l₂) --->
   foldr patt_imp r (l₁ ++ a :: q :: l₂) --->
   foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)
using BasicReasoning
    eapply cast_proof'.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
(foldr patt_imp r (l₁ ++ a :: p :: l₂) --->
 foldr patt_imp r (l₁ ++ a :: q :: l₂) --->
 foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) = ?ϕ
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ ⊢i ?ϕ using BasicReasoning
    {
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
(foldr patt_imp r (l₁ ++ a :: p :: l₂) --->
 foldr patt_imp r (l₁ ++ a :: q :: l₂) --->
 foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) = ?ϕ
      replace (l₁ ++ a :: p :: l₂) with ((l₁ ++ [a]) ++ [p] ++ l₂) by (rewrite <- app_assoc; reflexivity).
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
(foldr patt_imp r ((l₁ ++ [a]) ++ [p] ++ l₂) --->
 foldr patt_imp r (l₁ ++ a :: q :: l₂) --->
 foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) = ?ϕ
      replace (l₁ ++ a :: q :: l₂) with ((l₁ ++ [a]) ++ [q] ++ l₂) by (rewrite <- app_assoc; reflexivity).
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
(foldr patt_imp r ((l₁ ++ [a]) ++ [p] ++ l₂) --->
 foldr patt_imp r ((l₁ ++ [a]) ++ [q] ++ l₂) --->
 foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) = ?ϕ
      replace (l₁ ++ a :: (p or q) :: l₂) with ((l₁ ++ [a]) ++ [p or q] ++ l₂) by (rewrite <- app_assoc; reflexivity).
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
(foldr patt_imp r ((l₁ ++ [a]) ++ [p] ++ l₂) --->
 foldr patt_imp r ((l₁ ++ [a]) ++ [q] ++ l₂) --->
 foldr patt_imp r ((l₁ ++ [a]) ++ [p or q] ++ l₂)) =
?ϕ
      reflexivity.
    }
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂
→ ∀ l₁ : list Pattern,
    Pattern.wf l₁
    → Γ
      ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
         foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
         foldr patt_imp r
           (l₁ ++ [p or q] ++ l₂)
      using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C =
foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ
⊢i foldr patt_imp r ((l₁ ++ [a]) ++ [p] ++ l₂) --->
   foldr patt_imp r ((l₁ ++ [a]) ++ [q] ++ l₂) --->
   foldr patt_imp r ((l₁ ++ [a]) ++ [p or q] ++ l₂)
using BasicReasoning
    apply IHl₂; wf_auto2.
Defined.

Lemma prf_disj_elim_iter_2_meta {Σ : Signature} Γ l₁ l₂ p q r i:
  Pattern.wf l₁ ->
  Pattern.wf l₂ ->
  well_formed p ->
  well_formed q ->
  well_formed r ->
  Γ ⊢i (fold_right patt_imp r (l₁ ++ [p] ++ l₂)) using i ->
  Γ ⊢i ((fold_right patt_imp r (l₁ ++ [q] ++ l₂))
            --->
            (fold_right patt_imp r (l₁ ++ [p or q] ++ l₂))) using i.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo
Pattern.wf l₁
→ Pattern.wf l₂
  → well_formed p
    → well_formed q
      → well_formed r
        → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂)
          using i
          → Γ
            ⊢i foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
               foldr patt_imp r (l₁ ++ [p or q] ++ l₂)
            using i
Proof.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo
Pattern.wf l₁
→ Pattern.wf l₂
  → well_formed p
    → well_formed q
      → well_formed r
        → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂)
          using i
          → Γ
            ⊢i foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
               foldr patt_imp r (l₁ ++ [p or q] ++ l₂)
            using i
  intros WFl1 WFl2 WFp WFq WFr H.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo
WFl1: Pattern.wf l₁
WFl2: Pattern.wf l₂
WFp: well_formed p
WFq: well_formed q
WFr: well_formed r
H: Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i
Γ
⊢i foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
   foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using i
  eapply MP.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo
WFl1: Pattern.wf l₁
WFl2: Pattern.wf l₂
WFp: well_formed p
WFq: well_formed q
WFr: well_formed r
H: Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo
WFl1: Pattern.wf l₁
WFl2: Pattern.wf l₂
WFp: well_formed p
WFq: well_formed q
WFr: well_formed r
H: Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i
Γ
⊢i ?ϕ₁ --->
   foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
   foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using i
  apply H.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo
WFl1: Pattern.wf l₁
WFl2: Pattern.wf l₂
WFp: well_formed p
WFq: well_formed q
WFr: well_formed r
H: Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i
Γ
⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
   foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
   foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using i
  useBasicReasoning.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo
WFl1: Pattern.wf l₁
WFl2: Pattern.wf l₂
WFp: well_formed p
WFq: well_formed q
WFr: well_formed r
H: Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i
Γ
⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) --->
   foldr patt_imp r (l₁ ++ [q] ++ l₂) --->
   foldr patt_imp r (l₁ ++ [p or q] ++ l₂)
using BasicReasoning
  apply prf_disj_elim_iter_2; wf_auto2.
Defined.

Lemma prf_disj_elim_iter_2_meta_meta {Σ : Signature} Γ l₁ l₂ p q r i:
  Pattern.wf l₁ ->
  Pattern.wf l₂ ->
  well_formed p ->
  well_formed q ->
  well_formed r ->
  Γ ⊢i (fold_right patt_imp r (l₁ ++ [p] ++ l₂)) using i ->
  Γ ⊢i (fold_right patt_imp r (l₁ ++ [q] ++ l₂)) using i ->
  Γ ⊢i (fold_right patt_imp r (l₁ ++ [p or q] ++ l₂)) using i.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo
Pattern.wf l₁
→ Pattern.wf l₂
  → well_formed p
    → well_formed q
      → well_formed r
        → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂)
          using i
          → Γ ⊢i foldr patt_imp r (l₁ ++ [q] ++ l₂)
            using i
            → Γ
              ⊢i foldr patt_imp r
                   (l₁ ++ [p or q] ++ l₂) using i
Proof.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo
Pattern.wf l₁
→ Pattern.wf l₂
  → well_formed p
    → well_formed q
      → well_formed r
        → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂)
          using i
          → Γ ⊢i foldr patt_imp r (l₁ ++ [q] ++ l₂)
            using i
            → Γ
              ⊢i foldr patt_imp r
                   (l₁ ++ [p or q] ++ l₂) using i
  intros WFl1 WFl2 WFp WFq WFr H H0.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo
WFl1: Pattern.wf l₁
WFl2: Pattern.wf l₂
WFp: well_formed p
WFq: well_formed q
WFr: well_formed r
H: Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i
H0: Γ ⊢i foldr patt_imp r (l₁ ++ [q] ++ l₂) using i
Γ ⊢i foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using i
  eapply MP.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo
WFl1: Pattern.wf l₁
WFl2: Pattern.wf l₂
WFp: well_formed p
WFq: well_formed q
WFr: well_formed r
H: Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i
H0: Γ ⊢i foldr patt_imp r (l₁ ++ [q] ++ l₂) using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo
WFl1: Pattern.wf l₁
WFl2: Pattern.wf l₂
WFp: well_formed p
WFq: well_formed q
WFr: well_formed r
H: Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i
H0: Γ ⊢i foldr patt_imp r (l₁ ++ [q] ++ l₂) using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂)
using i
  2: {
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo
WFl1: Pattern.wf l₁
WFl2: Pattern.wf l₂
WFp: well_formed p
WFq: well_formed q
WFr: well_formed r
H: Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i
H0: Γ ⊢i foldr patt_imp r (l₁ ++ [q] ++ l₂) using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂)
using i apply prf_disj_elim_iter_2_meta; try_wfauto2.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo
WFl1: Pattern.wf l₁
WFl2: Pattern.wf l₂
WFp: well_formed p
WFq: well_formed q
WFr: well_formed r
H: Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i
H0: Γ ⊢i foldr patt_imp r (l₁ ++ [q] ++ l₂) using i
Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i apply H. }
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo
WFl1: Pattern.wf l₁
WFl2: Pattern.wf l₂
WFp: well_formed p
WFq: well_formed q
WFr: well_formed r
H: Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i
H0: Γ ⊢i foldr patt_imp r (l₁ ++ [q] ++ l₂) using i
Γ ⊢i foldr patt_imp r (l₁ ++ [q] ++ l₂) using i
  apply H0.
Defined.

Lemma MLGoal_disj_elim {Σ : Signature} Γ l₁ l₂ pn p qn q pqn r i:
  mkMLGoal Σ Γ (l₁ ++ [mkNH _ pn p] ++ l₂) r i ->
  mkMLGoal Σ Γ (l₁ ++ [mkNH _ qn q] ++ l₂) r i ->
  mkMLGoal Σ Γ (l₁ ++ [mkNH _ pqn (p or q)] ++ l₂) r i.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
Γ Ⱶ
l₁ ++ (pn ∶ p,
       ) ++ l₂--------------------------------------
r
using i

→ Γ Ⱶ
  l₁ ++ (qn ∶ q,
         ) ++ l₂--------------------------------------
  r
  using i
  
  → Γ Ⱶ
  l₁ ++ (pqn ∶ p or q,
         ) ++ l₂--------------------------------------
  r
  using i
  
Proof.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
Γ Ⱶ
l₁ ++ (pn ∶ p,
       ) ++ l₂--------------------------------------
r
using i

→ Γ Ⱶ
  l₁ ++ (qn ∶ q,
         ) ++ l₂--------------------------------------
  r
  using i
  
  → Γ Ⱶ
  l₁ ++ (pqn ∶ p or q,
         ) ++ l₂--------------------------------------
  r
  using i
  
  intros H1 H2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
H1: Γ Ⱶ
l₁ ++ (pn ∶ p,
       ) ++ l₂--------------------------------------
r
using i

H2: Γ Ⱶ
l₁ ++ (qn ∶ q,
       ) ++ l₂--------------------------------------
r
using i

Γ Ⱶ
l₁ ++ (pqn ∶ p or q,
       ) ++ l₂--------------------------------------
r
using i

  unfold of_MLGoal in *.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
H1: well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (pn ∶ p,
             ) ++ l₂--------------------------------------
      r
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l₁ ++ (pn ∶ p,
                  ) ++ l₂--------------------------------------
           r
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       l₁ ++ (pn ∶ p,
              ) ++ l₂--------------------------------------
       r
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l₁ ++ (pn ∶ p,
                    ) ++ l₂--------------------------------------
             r
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l₁ ++ (pn ∶ p,
                       ) ++ l₂--------------------------------------
                r
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             l₁ ++ (pn ∶ p,
                    ) ++ l₂--------------------------------------
             r
             using i
             )
H2: well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (qn ∶ q,
             ) ++ l₂--------------------------------------
      r
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l₁ ++ (qn ∶ q,
                  ) ++ l₂--------------------------------------
           r
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       l₁ ++ (qn ∶ q,
              ) ++ l₂--------------------------------------
       r
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l₁ ++ (qn ∶ q,
                    ) ++ l₂--------------------------------------
             r
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l₁ ++ (qn ∶ q,
                       ) ++ l₂--------------------------------------
                r
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             l₁ ++ (qn ∶ q,
                    ) ++ l₂--------------------------------------
             r
             using i
             )
well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (pqn ∶ p or q,
             ) ++ l₂--------------------------------------
      r
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l₁ ++ (pqn ∶ p or q,
                  ) ++ l₂--------------------------------------
           r
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       l₁ ++ (pqn ∶ p or q,
              ) ++ l₂--------------------------------------
       r
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l₁ ++ (pqn ∶ p or q,
                    ) ++ l₂--------------------------------------
             r
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l₁ ++ (pqn ∶ p or q,
                       ) ++ l₂--------------------------------------
                r
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             l₁ ++ (pqn ∶ p or q,
                    ) ++ l₂--------------------------------------
             r
             using i
             ) simpl in *.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
H1: well_formed r
→ Pattern.wf (patterns_of (l₁ ++ (pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (patterns_of (l₁ ++ (pn ∶ p) :: l₂))
    using i
H2: well_formed r
→ Pattern.wf (patterns_of (l₁ ++ (qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (patterns_of (l₁ ++ (qn ∶ q) :: l₂))
    using i
well_formed r
→ Pattern.wf
    (patterns_of (l₁ ++ (pqn ∶ p or q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (patterns_of (l₁ ++ (pqn ∶ p or q) :: l₂))
    using i
  intros wfr Hwf.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
H1: well_formed r
→ Pattern.wf (patterns_of (l₁ ++ (pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (patterns_of (l₁ ++ (pn ∶ p) :: l₂))
    using i
H2: well_formed r
→ Pattern.wf (patterns_of (l₁ ++ (qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (patterns_of (l₁ ++ (qn ∶ q) :: l₂))
    using i
wfr: well_formed r
Hwf: Pattern.wf (patterns_of (l₁ ++ (pqn ∶ p or q) :: l₂))
Γ
⊢i foldr patt_imp r
     (patterns_of (l₁ ++ (pqn ∶ p or q) :: l₂))
using i
  unfold patterns_of in *.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
H1: well_formed r
→ Pattern.wf (map nh_patt (l₁ ++ (pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt (l₁ ++ (pn ∶ p) :: l₂))
    using i
H2: well_formed r
→ Pattern.wf (map nh_patt (l₁ ++ (qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt (l₁ ++ (qn ∶ q) :: l₂))
    using i
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
Γ
⊢i foldr patt_imp r
     (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
using i
  rewrite map_app.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
H1: well_formed r
→ Pattern.wf (map nh_patt (l₁ ++ (pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt (l₁ ++ (pn ∶ p) :: l₂))
    using i
H2: well_formed r
→ Pattern.wf (map nh_patt (l₁ ++ (qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt (l₁ ++ (qn ∶ q) :: l₂))
    using i
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
Γ
⊢i foldr patt_imp r
     (map nh_patt l₁ ++
      map nh_patt ((pqn ∶ p or q) :: l₂)) using i
  rewrite map_app in H1.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
H2: well_formed r
→ Pattern.wf (map nh_patt (l₁ ++ (qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt (l₁ ++ (qn ∶ q) :: l₂))
    using i
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
Γ
⊢i foldr patt_imp r
     (map nh_patt l₁ ++
      map nh_patt ((pqn ∶ p or q) :: l₂)) using i
  rewrite map_app in H2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Γ
⊢i foldr patt_imp r
     (map nh_patt l₁ ++
      map nh_patt ((pqn ∶ p or q) :: l₂)) using i
  apply prf_disj_elim_iter_2_meta_meta.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Pattern.wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l₂)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
well_formed p
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
well_formed q
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
well_formed r
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Γ
⊢i foldr patt_imp r
     (map nh_patt l₁ ++
      [p] ++
      (fix map (l : list named_hypothesis) :
           list Pattern :=
         match l with
         | [] => []
         | a :: t => nh_patt a :: map t
         end) l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Γ
⊢i foldr patt_imp r
     (map nh_patt l₁ ++
      [q] ++
      (fix map (l : list named_hypothesis) :
           list Pattern :=
         match l with
         | [] => []
         | a :: t => nh_patt a :: map t
         end) l₂) using i
  7: apply H2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Pattern.wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l₂)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
well_formed p
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
well_formed q
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
well_formed r
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Γ
⊢i foldr patt_imp r
     (map nh_patt l₁ ++
      [p] ++
      (fix map (l : list named_hypothesis) :
           list Pattern :=
         match l with
         | [] => []
         | a :: t => nh_patt a :: map t
         end) l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
well_formed r
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂))
  6: apply H1.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Pattern.wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l₂)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
well_formed p
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
well_formed q
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
well_formed r
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
well_formed r
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
well_formed r
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂))
  all: try assumption; unfold patterns_of in *; rewrite map_app in Hwf.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l₂)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
well_formed p
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
well_formed q
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂))
  {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf (map nh_patt l₁) abstract (apply wfl₁hl₂_proj_l₁ in Hwf; exact Hwf). }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l₂)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
well_formed p
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
well_formed q
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂))
  {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l₂) abstract (apply wfl₁hl₂_proj_l₂ in Hwf; exact Hwf). }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
well_formed p
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
well_formed q
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂))
  {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
well_formed p abstract (apply wfl₁hl₂_proj_h in Hwf; wf_auto2). }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
well_formed q
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂))
  {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
well_formed q abstract (apply wfl₁hl₂_proj_h in Hwf; wf_auto2). }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂))
  {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂))
    pose proof (wfl₁hl₂_proj_l₁ _ _ _ Hwf).
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
H: Pattern.wf (map nh_patt l₁)
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂))
    pose proof (wfl₁hl₂_proj_h _ _ _ Hwf).
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
H: Pattern.wf (map nh_patt l₁)
H0: well_formed (nh_patt (pqn ∶ p or q))
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂))
    pose proof (wfl₁hl₂_proj_l₂ _ _ _ Hwf).
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
H: Pattern.wf (map nh_patt l₁)
H0: well_formed (nh_patt (pqn ∶ p or q))
H3: Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l₂)
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂))
    apply wf_app; [assumption|].
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
H: Pattern.wf (map nh_patt l₁)
H0: well_formed (nh_patt (pqn ∶ p or q))
H3: Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l₂)
Pattern.wf (map nh_patt ((pn ∶ p) :: l₂)) = true
    unfold patt_or,patt_not in *.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ (p ---> ⊥) ---> q) :: l₂))
H: Pattern.wf (map nh_patt l₁)
H0: well_formed (nh_patt (pqn ∶ (p ---> ⊥) ---> q))
H3: Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l₂)
Pattern.wf (map nh_patt ((pn ∶ p) :: l₂)) = true
    simpl.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ (p ---> ⊥) ---> q) :: l₂))
H: Pattern.wf (map nh_patt l₁)
H0: well_formed (nh_patt (pqn ∶ (p ---> ⊥) ---> q))
H3: Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l₂)
Pattern.wf (p :: map nh_patt l₂) = true
    wf_auto2.
  }
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂))
  {
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂))
    pose proof (wfl₁hl₂_proj_l₁ _ _ _ Hwf).
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
H: Pattern.wf (map nh_patt l₁)
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂))
    pose proof (wfl₁hl₂_proj_h _ _ _ Hwf).
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
H: Pattern.wf (map nh_patt l₁)
H0: well_formed (nh_patt (pqn ∶ p or q))
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂))
    pose proof (wfl₁hl₂_proj_l₂ _ _ _ Hwf).
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
H: Pattern.wf (map nh_patt l₁)
H0: well_formed (nh_patt (pqn ∶ p or q))
H3: Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l₂)
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂))
    apply wf_app; [assumption|].
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
H: Pattern.wf (map nh_patt l₁)
H0: well_formed (nh_patt (pqn ∶ p or q))
H3: Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l₂)
Pattern.wf (map nh_patt ((qn ∶ q) :: l₂)) = true
    unfold patt_or,patt_not in *.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ (p ---> ⊥) ---> q) :: l₂))
H: Pattern.wf (map nh_patt l₁)
H0: well_formed (nh_patt (pqn ∶ (p ---> ⊥) ---> q))
H3: Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l₂)
Pattern.wf (map nh_patt ((qn ∶ q) :: l₂)) = true
    simpl.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((pn ∶ p) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r
→ Pattern.wf
    (map nh_patt l₁ ++
     map nh_patt ((qn ∶ q) :: l₂))
  → Γ
    ⊢i foldr patt_imp r
         (map nh_patt l₁ ++
          map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ (p ---> ⊥) ---> q) :: l₂))
H: Pattern.wf (map nh_patt l₁)
H0: well_formed (nh_patt (pqn ∶ (p ---> ⊥) ---> q))
H3: Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l₂)
Pattern.wf (q :: map nh_patt l₂) = true
    wf_auto2.
  }
Defined.

Tactic Notation "mlDestructOr" constr(name) "as" constr(name1) constr(name2) :=
  _ensureProofMode;
  _failIfUsed name1; _failIfUsed name2;
  match goal with
  | |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm ?Ctx ?l ?g ?i) =>
    let Htd := fresh "Htd" in
    eapply cast_proof_ml_hyps;
    f_equal;
    _mlReshapeHypsByName name;
    apply MLGoal_disj_elim with (pqn := name) (pn := name1) (qn := name2);
    _mlReshapeHypsBack;
    simpl
  end.

Tactic Notation "mlDestructOr" constr(name) :=
  _ensureProofMode;
  let hyps := _getHypNames in
  let name0 := eval cbv in (fresh hyps) in
  let name1 := eval cbv in (fresh (name0 :: hyps)) in
  mlDestructOr name as name0 name1.

Local Example exd {Σ : Signature} Γ a b p q c i:
  well_formed a ->
  well_formed b ->
  well_formed p ->
  well_formed q ->
  well_formed c ->
  Γ ⊢i (a ---> p ---> b ---> c) using i ->
  Γ ⊢i (a ---> q ---> b ---> c) using i->
  Γ ⊢i (a ---> (p or q) ---> b ---> c) using i.
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
well_formed a
→ well_formed b
  → well_formed p
    → well_formed q
      → well_formed c
        → Γ ⊢i a ---> p ---> b ---> c using i
          → Γ ⊢i a ---> q ---> b ---> c using i
            → Γ ⊢i a ---> p or q ---> b ---> c using i
Proof.
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
well_formed a
→ well_formed b
  → well_formed p
    → well_formed q
      → well_formed c
        → Γ ⊢i a ---> p ---> b ---> c using i
          → Γ ⊢i a ---> q ---> b ---> c using i
            → Γ ⊢i a ---> p or q ---> b ---> c using i
  intros WFa WFb WFp WFq WFc H H0.
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i
Γ ⊢i a ---> p or q ---> b ---> c using i
  toMLGoal.
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i
well_formed (a ---> p or q ---> b ---> c)
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i
Γ Ⱶ
a ---> p or q ---> b ---> c
using i

  {
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i
well_formed (a ---> p or q ---> b ---> c) wf_auto2. }
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i
Γ Ⱶ
a ---> p or q ---> b ---> c
using i
 
  mlIntro "H0".
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i
Γ Ⱶ
"H0" ∶ a,
--------------------------------------
p or q ---> b ---> c
using i

  mlIntro "H1".
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ p or q,
--------------------------------------
b ---> c
using i

  mlIntro "H2".
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ p or q,
"H2" ∶ b,
--------------------------------------
c
using i

  mlDestructOr "H1".
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i
Γ Ⱶ
"H0" ∶ a,
"0" ∶ p,
"H2" ∶ b,
--------------------------------------
c
using i
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i
Γ Ⱶ
"H0" ∶ a,
"1" ∶ q,
"H2" ∶ b,
--------------------------------------
c
using i

  -
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i
Γ Ⱶ
"H0" ∶ a,
"0" ∶ p,
"H2" ∶ b,
--------------------------------------
c
using i
 fromMLGoal.
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i
Γ ⊢i a ---> p ---> b ---> c using i apply H.
  -
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i
Γ Ⱶ
"H0" ∶ a,
"1" ∶ q,
"H2" ∶ b,
--------------------------------------
c
using i
 fromMLGoal.
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i
Γ ⊢i a ---> q ---> b ---> c using i apply H0.
Defined.

Lemma pf_iff_split {Σ : Signature} Γ A B i:
  well_formed A ->
  well_formed B ->
  Γ ⊢i A ---> B using i ->
  Γ ⊢i B ---> A using i ->
  Γ ⊢i A <---> B using i.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
well_formed A
→ well_formed B
  → Γ ⊢i A ---> B using i
    → Γ ⊢i B ---> A using i → Γ ⊢i A <---> B using i
Proof.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
well_formed A
→ well_formed B
  → Γ ⊢i A ---> B using i
    → Γ ⊢i B ---> A using i → Γ ⊢i A <---> B using i
  intros wfA wfB AimplB BimplA.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
AimplB: Γ ⊢i A ---> B using i
BimplA: Γ ⊢i B ---> A using i
Γ ⊢i A <---> B using i
  unfold patt_iff.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
AimplB: Γ ⊢i A ---> B using i
BimplA: Γ ⊢i B ---> A using i
Γ ⊢i (A ---> B) and (B ---> A) using i
  apply conj_intro_meta; try_wfauto2; assumption.
Defined.

Lemma pf_iff_proj1 {Σ : Signature} Γ A B i:
  well_formed A ->
  well_formed B ->
  Γ ⊢i A <---> B using i ->
  Γ ⊢i A ---> B using i.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
well_formed A
→ well_formed B
  → Γ ⊢i A <---> B using i → Γ ⊢i A ---> B using i
Proof.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
well_formed A
→ well_formed B
  → Γ ⊢i A <---> B using i → Γ ⊢i A ---> B using i
  intros WFA WFB H.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A <---> B using i
Γ ⊢i A ---> B using i unfold patt_iff in H.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i (A ---> B) and (B ---> A) using i
Γ ⊢i A ---> B using i
  apply pf_conj_elim_l_meta in H; try_wfauto2; assumption.
Defined.

Lemma pf_iff_proj2 {Σ : Signature} Γ A B i:
  well_formed A ->
  well_formed B ->
  Γ ⊢i (A <---> B) using i ->
  Γ ⊢i (B ---> A) using i.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
well_formed A
→ well_formed B
  → Γ ⊢i A <---> B using i → Γ ⊢i B ---> A using i
Proof.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
well_formed A
→ well_formed B
  → Γ ⊢i A <---> B using i → Γ ⊢i B ---> A using i
  intros WFA WFB H.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A <---> B using i
Γ ⊢i B ---> A using i unfold patt_iff in H.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i (A ---> B) and (B ---> A) using i
Γ ⊢i B ---> A using i
  apply pf_conj_elim_r_meta in H; try_wfauto2; assumption.
Defined.

Lemma pf_iff_iff {Σ : Signature} Γ A B i:
  well_formed A ->
  well_formed B ->
  prod ((Γ ⊢i (A <---> B) using i) -> (prod (Γ ⊢i (A ---> B) using i) (Γ ⊢i (B ---> A) using i)))
  ( (prod (Γ ⊢i (A ---> B) using i)  (Γ ⊢i (B ---> A) using i)) -> (Γ ⊢i (A <---> B) using i)).
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
well_formed A
→ well_formed B
  → (Γ ⊢i A <---> B using i
     → (Γ ⊢i A ---> B using i) *
       (Γ ⊢i B ---> A using i)) *
    ((Γ ⊢i A ---> B using i) * (Γ ⊢i B ---> A using i)
     → Γ ⊢i A <---> B using i)
Proof.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
well_formed A
→ well_formed B
  → (Γ ⊢i A <---> B using i
     → (Γ ⊢i A ---> B using i) *
       (Γ ⊢i B ---> A using i)) *
    ((Γ ⊢i A ---> B using i) * (Γ ⊢i B ---> A using i)
     → Γ ⊢i A <---> B using i)
  intros WFA WFB.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
((Γ ⊢i A <---> B using i
  → (Γ ⊢i A ---> B using i) * (Γ ⊢i B ---> A using i)) *
 ((Γ ⊢i A ---> B using i) * (Γ ⊢i B ---> A using i)
  → Γ ⊢i A <---> B using i))%type
  split; intros H.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A <---> B using i
((Γ ⊢i A ---> B using i) * (Γ ⊢i B ---> A using i))%type
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: ((Γ ⊢i A ---> B using i) * (Γ ⊢i B ---> A using i))%type
Γ ⊢i A <---> B using i
  {
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A <---> B using i
((Γ ⊢i A ---> B using i) * (Γ ⊢i B ---> A using i))%type
    pose proof (H1 := pf_iff_proj1 _ _ _ _ WFA WFB H).
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A <---> B using i
H1: Γ ⊢i A ---> B using i
((Γ ⊢i A ---> B using i) * (Γ ⊢i B ---> A using i))%type
    pose proof (H2 := pf_iff_proj2 _ _ _ _ WFA WFB H).
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A <---> B using i
H1: Γ ⊢i A ---> B using i
H2: Γ ⊢i B ---> A using i
((Γ ⊢i A ---> B using i) * (Γ ⊢i B ---> A using i))%type
    split; assumption.
  }
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: ((Γ ⊢i A ---> B using i) * (Γ ⊢i B ---> A using i))%type
Γ ⊢i A <---> B using i
  {
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: ((Γ ⊢i A ---> B using i) * (Γ ⊢i B ---> A using i))%type
Γ ⊢i A <---> B using i
    destruct H as [H1 H2].
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H1: Γ ⊢i A ---> B using i
H2: Γ ⊢i B ---> A using i
Γ ⊢i A <---> B using i
    apply pf_iff_split; assumption.
  }
Defined.

Lemma pf_iff_equiv_refl {Σ : Signature} Γ A :
  well_formed A ->
  Γ ⊢i (A <---> A) using BasicReasoning.
Σ: Signature
Γ: Theory
A: Pattern
well_formed A → Γ ⊢i A <---> A using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
A: Pattern
well_formed A → Γ ⊢i A <---> A using BasicReasoning
  intros WFA.
Σ: Signature
Γ: Theory
A: Pattern
WFA: well_formed A
Γ ⊢i A <---> A using BasicReasoning
  apply pf_iff_split; try_wfauto2; apply A_impl_A; assumption.
Defined.

Lemma pf_iff_equiv_sym {Σ : Signature} Γ A B i:
  well_formed A ->
  well_formed B ->
  Γ ⊢i (A <---> B) using i ->
  Γ ⊢i (B <---> A) using i.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
well_formed A
→ well_formed B
  → Γ ⊢i A <---> B using i → Γ ⊢i B <---> A using i
Proof.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
well_formed A
→ well_formed B
  → Γ ⊢i A <---> B using i → Γ ⊢i B <---> A using i
  intros wfA wfB H.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
H: Γ ⊢i A <---> B using i
Γ ⊢i B <---> A using i
  pose proof (H2 := H).
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
H, H2: Γ ⊢i A <---> B using i
Γ ⊢i B <---> A using i
  apply pf_iff_proj2 in H2; try_wfauto2.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
H: Γ ⊢i A <---> B using i
H2: Γ ⊢i B ---> A using i
Γ ⊢i B <---> A using i
  rename H into H1.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
H1: Γ ⊢i A <---> B using i
H2: Γ ⊢i B ---> A using i
Γ ⊢i B <---> A using i
  apply pf_iff_proj1 in H1; try_wfauto2.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
H1: Γ ⊢i A ---> B using i
H2: Γ ⊢i B ---> A using i
Γ ⊢i B <---> A using i
  apply pf_iff_split; try_wfauto2; assumption.
Defined.

Lemma pf_iff_equiv_trans {Σ : Signature} Γ A B C i:
  well_formed A ->
  well_formed B ->
  well_formed C ->
  Γ ⊢i (A <---> B) using i ->
  Γ ⊢i (B <---> C) using i ->
  Γ ⊢i (A <---> C) using i.
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
well_formed A
→ well_formed B
  → well_formed C
    → Γ ⊢i A <---> B using i
      → Γ ⊢i B <---> C using i
        → Γ ⊢i A <---> C using i
Proof.
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
well_formed A
→ well_formed B
  → well_formed C
    → Γ ⊢i A <---> B using i
      → Γ ⊢i B <---> C using i
        → Γ ⊢i A <---> C using i
  intros wfA wfB wfC AeqB BeqC.
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AeqB: Γ ⊢i A <---> B using i
BeqC: Γ ⊢i B <---> C using i
Γ ⊢i A <---> C using i
  apply pf_iff_iff in AeqB; try_wfauto2.
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AeqB: ((Γ ⊢i A ---> B using i) *
 (Γ ⊢i B ---> A using i))%type
BeqC: Γ ⊢i B <---> C using i
Γ ⊢i A <---> C using i destruct AeqB as [AimpB BimpA].
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BeqC: Γ ⊢i B <---> C using i
Γ ⊢i A <---> C using i
  apply pf_iff_iff in BeqC; try_wfauto2.
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BeqC: ((Γ ⊢i B ---> C using i) *
 (Γ ⊢i C ---> B using i))%type
Γ ⊢i A <---> C using i destruct BeqC as [BimpC CimpB].
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
Γ ⊢i A <---> C using i
  apply pf_iff_iff; try_wfauto2.
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
((Γ ⊢i A ---> C using i) * (Γ ⊢i C ---> A using i))%type
  split.
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
Γ ⊢i A ---> C using i
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
Γ ⊢i C ---> A using i
  {
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
Γ ⊢i A ---> C using i
    eapply syllogism_meta.
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
well_formed A
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
well_formed ?B
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
well_formed C
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
Γ ⊢i A ---> ?B using i
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
Γ ⊢i ?B ---> C using i 4,5: eassumption.
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
well_formed A
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
well_formed B
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
well_formed C
    1-3: wf_auto2.
  }
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
Γ ⊢i C ---> A using i
  {
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
Γ ⊢i C ---> A using i
    eapply syllogism_meta.
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
well_formed C
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
well_formed ?B
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
well_formed A
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
Γ ⊢i C ---> ?B using i
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
Γ ⊢i ?B ---> A using i 4,5: eassumption.
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
well_formed C
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
well_formed B
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
well_formed A
    1-3: wf_auto2.
  }
Defined.

Lemma prf_conclusion {Σ : Signature} Γ a b i:
  well_formed a ->
  well_formed b ->
  Γ ⊢i b using i ->
  Γ ⊢i (a ---> b) using i.
Σ: Signature
Γ: Theory
a, b: Pattern
i: ProofInfo
well_formed a
→ well_formed b
  → Γ ⊢i b using i → Γ ⊢i a ---> b using i
Proof.
Σ: Signature
Γ: Theory
a, b: Pattern
i: ProofInfo
well_formed a
→ well_formed b
  → Γ ⊢i b using i → Γ ⊢i a ---> b using i
  intros WFa WFb H.
Σ: Signature
Γ: Theory
a, b: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
H: Γ ⊢i b using i
Γ ⊢i a ---> b using i eapply MP.
Σ: Signature
Γ: Theory
a, b: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
H: Γ ⊢i b using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
a, b: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
H: Γ ⊢i b using i
Γ ⊢i ?ϕ₁ ---> a ---> b using i
  apply H.
Σ: Signature
Γ: Theory
a, b: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
H: Γ ⊢i b using i
Γ ⊢i b ---> a ---> b using i
  useBasicReasoning.
Σ: Signature
Γ: Theory
a, b: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
H: Γ ⊢i b using i
Γ ⊢i b ---> a ---> b using BasicReasoning
  apply P1; wf_auto2.
Defined.



Lemma and_of_negated_iff_not_impl {Σ : Signature} Γ p1 p2:
  well_formed p1 ->
  well_formed p2 ->
  Γ ⊢i (! (! p1 ---> p2) <---> ! p1 and ! p2)
  using BasicReasoning.
Σ: Signature
Γ: Theory
p1, p2: Pattern
well_formed p1
→ well_formed p2
  → Γ ⊢i ! (! p1 ---> p2) <---> ! p1 and ! p2
    using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
p1, p2: Pattern
well_formed p1
→ well_formed p2
  → Γ ⊢i ! (! p1 ---> p2) <---> ! p1 and ! p2
    using BasicReasoning
  intros wfp1 wfp2.
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i ! (! p1 ---> p2) <---> ! p1 and ! p2
using BasicReasoning
  apply conj_intro_meta.
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
well_formed (! (! p1 ---> p2) ---> ! p1 and ! p2)
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
well_formed (! p1 and ! p2 ---> ! (! p1 ---> p2))
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i ! (! p1 ---> p2) ---> ! p1 and ! p2
using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i ! p1 and ! p2 ---> ! (! p1 ---> p2)
using BasicReasoning
  {
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
well_formed (! (! p1 ---> p2) ---> ! p1 and ! p2) wf_auto2. }
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
well_formed (! p1 and ! p2 ---> ! (! p1 ---> p2))
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i ! (! p1 ---> p2) ---> ! p1 and ! p2
using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i ! p1 and ! p2 ---> ! (! p1 ---> p2)
using BasicReasoning
  {
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
well_formed (! p1 and ! p2 ---> ! (! p1 ---> p2)) wf_auto2. }
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i ! (! p1 ---> p2) ---> ! p1 and ! p2
using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i ! p1 and ! p2 ---> ! (! p1 ---> p2)
using BasicReasoning
  -
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i ! (! p1 ---> p2) ---> ! p1 and ! p2
using BasicReasoning toMLGoal.
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
well_formed (! (! p1 ---> p2) ---> ! p1 and ! p2)
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
! (! p1 ---> p2) ---> ! p1 and ! p2
using BasicReasoning

    {
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
well_formed (! (! p1 ---> p2) ---> ! p1 and ! p2) wf_auto2. }
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
! (! p1 ---> p2) ---> ! p1 and ! p2
using BasicReasoning

    mlIntro "H0".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H0" ∶ ! (! p1 ---> p2),
--------------------------------------
! p1 and ! p2
using BasicReasoning
 mlIntro "H1".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H0" ∶ ! (! p1 ---> p2),
"H1" ∶ ! ! p1 or ! ! p2,
--------------------------------------
⊥
using BasicReasoning

    mlApply "H0".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H0" ∶ (! p1 ---> p2) ---> ⊥,
"H1" ∶ ! ! p1 or ! ! p2,
--------------------------------------
! p1 ---> p2
using BasicReasoning

    mlIntro "H2".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H0" ∶ (! p1 ---> p2) ---> ⊥,
"H1" ∶ ! ! p1 or ! ! p2,
"H2" ∶ ! p1,
--------------------------------------
p2
using BasicReasoning

    unfold patt_or.
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H0" ∶ (! p1 ---> p2) ---> ⊥,
"H1" ∶ ! ! ! p1 ---> ! ! p2,
"H2" ∶ ! p1,
--------------------------------------
p2
using BasicReasoning

    mlAdd (not_not_elim Γ p2 ltac:(wf_auto2)) as "H3".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H3" ∶ ! ! p2 ---> p2,
"H0" ∶ (! p1 ---> p2) ---> ⊥,
"H1" ∶ ! ! ! p1 ---> ! ! p2,
"H2" ∶ ! p1,
--------------------------------------
p2
using BasicReasoning

    mlApply "H3".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H3" ∶ ! ! p2 ---> p2,
"H0" ∶ (! p1 ---> p2) ---> ⊥,
"H1" ∶ ! ! ! p1 ---> ! ! p2,
"H2" ∶ ! p1,
--------------------------------------
! ! p2
using BasicReasoning

    mlApply "H1".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H3" ∶ ! ! p2 ---> p2,
"H0" ∶ (! p1 ---> p2) ---> ⊥,
"H1" ∶ ! ! ! p1 ---> ! ! p2,
"H2" ∶ ! p1,
--------------------------------------
! ! ! p1
using BasicReasoning

    mlAdd (not_not_intro Γ (! p1) ltac:(wf_auto2)) as "H4".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H4" ∶ ! p1 ---> ! ! ! p1,
"H3" ∶ ! ! p2 ---> p2,
"H0" ∶ (! p1 ---> p2) ---> ⊥,
"H1" ∶ ! ! ! p1 ---> ! ! p2,
"H2" ∶ ! p1,
--------------------------------------
! ! ! p1
using BasicReasoning

    mlApply "H4".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H4" ∶ ! p1 ---> ! ! ! p1,
"H3" ∶ ! ! p2 ---> p2,
"H0" ∶ (! p1 ---> p2) ---> ⊥,
"H1" ∶ ! ! ! p1 ---> ! ! p2,
"H2" ∶ ! p1,
--------------------------------------
! p1
using BasicReasoning

    mlExact "H2".
  -
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i ! p1 and ! p2 ---> ! (! p1 ---> p2)
using BasicReasoning toMLGoal.
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
well_formed (! p1 and ! p2 ---> ! (! p1 ---> p2))
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
! p1 and ! p2 ---> ! (! p1 ---> p2)
using BasicReasoning

    {
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
well_formed (! p1 and ! p2 ---> ! (! p1 ---> p2)) wf_auto2. }
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
! p1 and ! p2 ---> ! (! p1 ---> p2)
using BasicReasoning

    mlIntro "H0".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H0" ∶ ! p1 and ! p2,
--------------------------------------
! (! p1 ---> p2)
using BasicReasoning
 mlIntro "H1".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H0" ∶ ! p1 and ! p2,
"H1" ∶ ! p1 ---> p2,
--------------------------------------
⊥
using BasicReasoning

    unfold patt_and.
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H0" ∶ ! (! ! p1 or ! ! p2),
"H1" ∶ ! p1 ---> p2,
--------------------------------------
⊥
using BasicReasoning

    mlApply "H0".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H0" ∶ ! ! p1 or ! ! p2 ---> ⊥,
"H1" ∶ ! p1 ---> p2,
--------------------------------------
! ! p1 or ! ! p2
using BasicReasoning

    unfold patt_or.
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H0" ∶ (! ! ! p1 ---> ! ! p2) ---> ⊥,
"H1" ∶ ! p1 ---> p2,
--------------------------------------
! ! ! p1 ---> ! ! p2
using BasicReasoning

    mlIntro "H2".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H0" ∶ (! ! ! p1 ---> ! ! p2) ---> ⊥,
"H1" ∶ ! p1 ---> p2,
"H2" ∶ ! ! ! p1,
--------------------------------------
! ! p2
using BasicReasoning

    mlAdd (@not_not_intro Σ Γ p2 ltac:(wf_auto2)) as "H3".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H3" ∶ p2 ---> ! ! p2,
"H0" ∶ (! ! ! p1 ---> ! ! p2) ---> ⊥,
"H1" ∶ ! p1 ---> p2,
"H2" ∶ ! ! ! p1,
--------------------------------------
! ! p2
using BasicReasoning

    mlApply "H3".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H3" ∶ p2 ---> ! ! p2,
"H0" ∶ (! ! ! p1 ---> ! ! p2) ---> ⊥,
"H1" ∶ ! p1 ---> p2,
"H2" ∶ ! ! ! p1,
--------------------------------------
p2
using BasicReasoning

    mlApply "H1".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H3" ∶ p2 ---> ! ! p2,
"H0" ∶ (! ! ! p1 ---> ! ! p2) ---> ⊥,
"H1" ∶ ! p1 ---> p2,
"H2" ∶ ! ! ! p1,
--------------------------------------
! p1
using BasicReasoning

    mlAdd (@not_not_elim Σ Γ (! p1) ltac:(wf_auto2)) as "H4".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H4" ∶ ! ! ! p1 ---> ! p1,
"H3" ∶ p2 ---> ! ! p2,
"H0" ∶ (! ! ! p1 ---> ! ! p2) ---> ⊥,
"H1" ∶ ! p1 ---> p2,
"H2" ∶ ! ! ! p1,
--------------------------------------
! p1
using BasicReasoning

    mlApply "H4".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H4" ∶ ! ! ! p1 ---> ! p1,
"H3" ∶ p2 ---> ! ! p2,
"H0" ∶ (! ! ! p1 ---> ! ! p2) ---> ⊥,
"H1" ∶ ! p1 ---> p2,
"H2" ∶ ! ! ! p1,
--------------------------------------
! ! ! p1
using BasicReasoning

    mlExact "H2".
Defined.

Lemma and_impl_2 {Σ : Signature} Γ p1 p2:
  well_formed p1 ->
  well_formed p2 ->
  Γ ⊢i (! (p1 ---> p2) <---> p1 and ! p2)
  using BasicReasoning.
Σ: Signature
Γ: Theory
p1, p2: Pattern
well_formed p1
→ well_formed p2
  → Γ ⊢i ! (p1 ---> p2) <---> p1 and ! p2
    using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
p1, p2: Pattern
well_formed p1
→ well_formed p2
  → Γ ⊢i ! (p1 ---> p2) <---> p1 and ! p2
    using BasicReasoning
  intros wfp1 wfp2.
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i ! (p1 ---> p2) <---> p1 and ! p2
using BasicReasoning
  apply conj_intro_meta.
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
well_formed (! (p1 ---> p2) ---> p1 and ! p2)
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
well_formed (p1 and ! p2 ---> ! (p1 ---> p2))
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i ! (p1 ---> p2) ---> p1 and ! p2
using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i p1 and ! p2 ---> ! (p1 ---> p2)
using BasicReasoning
  {
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
well_formed (! (p1 ---> p2) ---> p1 and ! p2) wf_auto2. }
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
well_formed (p1 and ! p2 ---> ! (p1 ---> p2))
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i ! (p1 ---> p2) ---> p1 and ! p2
using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i p1 and ! p2 ---> ! (p1 ---> p2)
using BasicReasoning
  {
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
well_formed (p1 and ! p2 ---> ! (p1 ---> p2)) wf_auto2. }
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i ! (p1 ---> p2) ---> p1 and ! p2
using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i p1 and ! p2 ---> ! (p1 ---> p2)
using BasicReasoning
  -
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i ! (p1 ---> p2) ---> p1 and ! p2
using BasicReasoning toMLGoal.
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
well_formed (! (p1 ---> p2) ---> p1 and ! p2)
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
! (p1 ---> p2) ---> p1 and ! p2
using BasicReasoning

    {
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
well_formed (! (p1 ---> p2) ---> p1 and ! p2) wf_auto2. }
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
! (p1 ---> p2) ---> p1 and ! p2
using BasicReasoning

    mlIntro "H0".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H0" ∶ ! (p1 ---> p2),
--------------------------------------
p1 and ! p2
using BasicReasoning
 mlIntro "H1".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H0" ∶ ! (p1 ---> p2),
"H1" ∶ ! p1 or ! ! p2,
--------------------------------------
⊥
using BasicReasoning

    mlApply "H0".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H0" ∶ (p1 ---> p2) ---> ⊥,
"H1" ∶ ! p1 or ! ! p2,
--------------------------------------
p1 ---> p2
using BasicReasoning

    mlIntro "H2".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H0" ∶ (p1 ---> p2) ---> ⊥,
"H1" ∶ ! p1 or ! ! p2,
"H2" ∶ p1,
--------------------------------------
p2
using BasicReasoning

    unfold patt_or.
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H0" ∶ (p1 ---> p2) ---> ⊥,
"H1" ∶ ! ! p1 ---> ! ! p2,
"H2" ∶ p1,
--------------------------------------
p2
using BasicReasoning

    mlAdd (not_not_elim Γ p2 ltac:(wf_auto2)) as "H3".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H3" ∶ ! ! p2 ---> p2,
"H0" ∶ (p1 ---> p2) ---> ⊥,
"H1" ∶ ! ! p1 ---> ! ! p2,
"H2" ∶ p1,
--------------------------------------
p2
using BasicReasoning

    mlApply "H3".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H3" ∶ ! ! p2 ---> p2,
"H0" ∶ (p1 ---> p2) ---> ⊥,
"H1" ∶ ! ! p1 ---> ! ! p2,
"H2" ∶ p1,
--------------------------------------
! ! p2
using BasicReasoning

    mlApply "H1".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H3" ∶ ! ! p2 ---> p2,
"H0" ∶ (p1 ---> p2) ---> ⊥,
"H1" ∶ ! ! p1 ---> ! ! p2,
"H2" ∶ p1,
--------------------------------------
! ! p1
using BasicReasoning

    mlAdd (not_not_intro Γ p1 ltac:(wf_auto2)) as "H4".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H4" ∶ p1 ---> ! ! p1,
"H3" ∶ ! ! p2 ---> p2,
"H0" ∶ (p1 ---> p2) ---> ⊥,
"H1" ∶ ! ! p1 ---> ! ! p2,
"H2" ∶ p1,
--------------------------------------
! ! p1
using BasicReasoning

    mlApply "H4".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H4" ∶ p1 ---> ! ! p1,
"H3" ∶ ! ! p2 ---> p2,
"H0" ∶ (p1 ---> p2) ---> ⊥,
"H1" ∶ ! ! p1 ---> ! ! p2,
"H2" ∶ p1,
--------------------------------------
p1
using BasicReasoning

    mlExact "H2".
  -
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i p1 and ! p2 ---> ! (p1 ---> p2)
using BasicReasoning toMLGoal.
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
well_formed (p1 and ! p2 ---> ! (p1 ---> p2))
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
p1 and ! p2 ---> ! (p1 ---> p2)
using BasicReasoning

    {
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
well_formed (p1 and ! p2 ---> ! (p1 ---> p2)) wf_auto2. }
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
p1 and ! p2 ---> ! (p1 ---> p2)
using BasicReasoning

    mlIntro "H0".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H0" ∶ p1 and ! p2,
--------------------------------------
! (p1 ---> p2)
using BasicReasoning
 mlIntro "H1".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H0" ∶ p1 and ! p2,
"H1" ∶ p1 ---> p2,
--------------------------------------
⊥
using BasicReasoning

    mlApply "H0".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H0" ∶ ! p1 or ! ! p2 ---> ⊥,
"H1" ∶ p1 ---> p2,
--------------------------------------
! p1 or ! ! p2
using BasicReasoning

    unfold patt_or.
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H0" ∶ (! ! p1 ---> ! ! p2) ---> ⊥,
"H1" ∶ p1 ---> p2,
--------------------------------------
! ! p1 ---> ! ! p2
using BasicReasoning

    mlIntro "H2".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H0" ∶ (! ! p1 ---> ! ! p2) ---> ⊥,
"H1" ∶ p1 ---> p2,
"H2" ∶ ! ! p1,
--------------------------------------
! ! p2
using BasicReasoning

    mlAdd (not_not_intro Γ p2 ltac:(wf_auto2)) as "H3".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H3" ∶ p2 ---> ! ! p2,
"H0" ∶ (! ! p1 ---> ! ! p2) ---> ⊥,
"H1" ∶ p1 ---> p2,
"H2" ∶ ! ! p1,
--------------------------------------
! ! p2
using BasicReasoning

    mlApply "H3".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H3" ∶ p2 ---> ! ! p2,
"H0" ∶ (! ! p1 ---> ! ! p2) ---> ⊥,
"H1" ∶ p1 ---> p2,
"H2" ∶ ! ! p1,
--------------------------------------
p2
using BasicReasoning

    mlApply "H1".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H3" ∶ p2 ---> ! ! p2,
"H0" ∶ (! ! p1 ---> ! ! p2) ---> ⊥,
"H1" ∶ p1 ---> p2,
"H2" ∶ ! ! p1,
--------------------------------------
p1
using BasicReasoning

    mlAdd (not_not_elim Γ p1 ltac:(wf_auto2)) as "H4".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H4" ∶ ! ! p1 ---> p1,
"H3" ∶ p2 ---> ! ! p2,
"H0" ∶ (! ! p1 ---> ! ! p2) ---> ⊥,
"H1" ∶ p1 ---> p2,
"H2" ∶ ! ! p1,
--------------------------------------
p1
using BasicReasoning

    mlApply "H4".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ
"H4" ∶ ! ! p1 ---> p1,
"H3" ∶ p2 ---> ! ! p2,
"H0" ∶ (! ! p1 ---> ! ! p2) ---> ⊥,
"H1" ∶ p1 ---> p2,
"H2" ∶ ! ! p1,
--------------------------------------
! ! p1
using BasicReasoning

    mlExact "H2".
Defined.

Lemma conj_intro_meta_partial {Σ : Signature} (Γ : Theory) (A B : Pattern) (i : ProofInfo) :
  well_formed A → well_formed B →
  Γ ⊢i A using i →
  Γ ⊢i B ---> (A and B) using i.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
well_formed A
→ well_formed B
  → Γ ⊢i A using i → Γ ⊢i B ---> A and B using i
Proof.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
well_formed A
→ well_formed B
  → Γ ⊢i A using i → Γ ⊢i B ---> A and B using i
  intros WFA WFB H.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i
Γ ⊢i B ---> A and B using i
  eapply MP.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i
Γ ⊢i ?ϕ₁ ---> B ---> A and B using i
  -
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i
Γ ⊢i ?ϕ₁ using i exact H.
  -
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i
Γ ⊢i A ---> B ---> A and B using i useBasicReasoning.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i
Γ ⊢i A ---> B ---> A and B using BasicReasoning apply conj_intro.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i
well_formed A
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i
well_formed B
    {
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i
well_formed A wf_auto2. }
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i
well_formed B
    {
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i
well_formed B wf_auto2. }
Defined.

Lemma and_impl_patt {Σ : Signature} (A B C : Pattern) Γ (i : ProofInfo):
  well_formed A → well_formed B → well_formed C →
  Γ ⊢i A using i ->
  Γ ⊢i ((A and B) ---> C) using i ->
  Γ ⊢i (B ---> C) using i.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
well_formed A
→ well_formed B
  → well_formed C
    → Γ ⊢i A using i
      → Γ ⊢i A and B ---> C using i
        → Γ ⊢i B ---> C using i
Proof.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
well_formed A
→ well_formed B
  → well_formed C
    → Γ ⊢i A using i
      → Γ ⊢i A and B ---> C using i
        → Γ ⊢i B ---> C using i
  intros WFA WFB WFC H H0.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
Γ ⊢i B ---> C using i
  eapply @syllogism_meta with (B := patt_and A B).
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
well_formed B
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
well_formed (A and B)
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
well_formed C
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
Γ ⊢i B ---> A and B using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
Γ ⊢i A and B ---> C using i
  {
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
well_formed B wf_auto2. }
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
well_formed (A and B)
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
well_formed C
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
Γ ⊢i B ---> A and B using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
Γ ⊢i A and B ---> C using i
  {
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
well_formed (A and B) wf_auto2. }
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
well_formed C
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
Γ ⊢i B ---> A and B using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
Γ ⊢i A and B ---> C using i
  {
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
well_formed C wf_auto2. }
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
Γ ⊢i B ---> A and B using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
Γ ⊢i A and B ---> C using i
  2: {
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
Γ ⊢i A and B ---> C using i exact H0. }
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
Γ ⊢i B ---> A and B using i
  apply conj_intro_meta_partial.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
well_formed A
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
well_formed B
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
Γ ⊢i A using i
  {
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
well_formed A wf_auto2. }
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
well_formed B
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
Γ ⊢i A using i
  {
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
well_formed B wf_auto2. }
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
Γ ⊢i A using i
  exact H.
Defined.

Lemma conj_intro2 {Σ : Signature} (Γ : Theory) (A B : Pattern) :
  well_formed A -> well_formed B ->
  Γ ⊢i (A ---> (B ---> (B and A)))
  using BasicReasoning.
Σ: Signature
Γ: Theory
A, B: Pattern
well_formed A
→ well_formed B
  → Γ ⊢i A ---> B ---> B and A using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
A, B: Pattern
well_formed A
→ well_formed B
  → Γ ⊢i A ---> B ---> B and A using BasicReasoning
  intros WFA WFB.
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B
Γ ⊢i A ---> B ---> B and A using BasicReasoning eapply reorder_meta.
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B
well_formed B
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B
well_formed A
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B
well_formed (B and A)
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B
Γ ⊢i B ---> A ---> B and A using BasicReasoning
  {
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B
well_formed B wf_auto2. }
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B
well_formed A
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B
well_formed (B and A)
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B
Γ ⊢i B ---> A ---> B and A using BasicReasoning
  {
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B
well_formed A wf_auto2. }
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B
well_formed (B and A)
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B
Γ ⊢i B ---> A ---> B and A using BasicReasoning
  {
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B
well_formed (B and A) wf_auto2. }
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B
Γ ⊢i B ---> A ---> B and A using BasicReasoning
  apply conj_intro.
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B
well_formed B
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B
well_formed A
  {
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B
well_formed B wf_auto2. }
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B
well_formed A
  {
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B
well_formed A wf_auto2. }
Defined.

Lemma conj_intro_meta_partial2  {Σ : Signature} (Γ : Theory) (A B : Pattern) (i : ProofInfo):
  well_formed A → well_formed B →
  Γ ⊢i A using i →
  Γ ⊢i B ---> (B and A) using i.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
well_formed A
→ well_formed B
  → Γ ⊢i A using i → Γ ⊢i B ---> B and A using i
Proof.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
well_formed A
→ well_formed B
  → Γ ⊢i A using i → Γ ⊢i B ---> B and A using i
  intros WFA WFB H.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i
Γ ⊢i B ---> B and A using i
  eapply MP.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i
Γ ⊢i ?ϕ₁ ---> B ---> B and A using i
  -
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i
Γ ⊢i ?ϕ₁ using i exact H.
  -
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i
Γ ⊢i A ---> B ---> B and A using i useBasicReasoning.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i
Γ ⊢i A ---> B ---> B and A using BasicReasoning apply conj_intro2.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i
well_formed A
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i
well_formed B
    {
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i
well_formed A wf_auto2. }
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i
well_formed B
    {
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i
well_formed B wf_auto2. }
Defined.

Lemma and_impl_patt2 {Σ : Signature}  (A B C : Pattern) Γ (i : ProofInfo):
  well_formed A → well_formed B → well_formed C →
  Γ ⊢i A using i ->
  Γ ⊢i ((B and A) ---> C) using i ->
  Γ ⊢i (B ---> C) using i.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
well_formed A
→ well_formed B
  → well_formed C
    → Γ ⊢i A using i
      → Γ ⊢i B and A ---> C using i
        → Γ ⊢i B ---> C using i
Proof.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
well_formed A
→ well_formed B
  → well_formed C
    → Γ ⊢i A using i
      → Γ ⊢i B and A ---> C using i
        → Γ ⊢i B ---> C using i
  intros WFA WFB WFC H H0.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
Γ ⊢i B ---> C using i
  eapply @syllogism_meta with (B := patt_and B A).
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
well_formed B
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
well_formed (B and A)
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
well_formed C
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
Γ ⊢i B ---> B and A using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
Γ ⊢i B and A ---> C using i
  {
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
well_formed B wf_auto2. }
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
well_formed (B and A)
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
well_formed C
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
Γ ⊢i B ---> B and A using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
Γ ⊢i B and A ---> C using i
  {
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
well_formed (B and A) wf_auto2. }
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
well_formed C
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
Γ ⊢i B ---> B and A using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
Γ ⊢i B and A ---> C using i
  {
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
well_formed C wf_auto2. }
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
Γ ⊢i B ---> B and A using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
Γ ⊢i B and A ---> C using i
  2: exact H0.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
Γ ⊢i B ---> B and A using i
  apply conj_intro_meta_partial2.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
well_formed A
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
well_formed B
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
Γ ⊢i A using i
  {
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
well_formed A wf_auto2. }
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
well_formed B
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
Γ ⊢i A using i
  {
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
well_formed B wf_auto2. }
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
Γ ⊢i A using i
  exact H.
Defined.


Lemma patt_and_comm_meta {Σ : Signature} (A B : Pattern) (Γ : Theory) (i : ProofInfo) :
  well_formed A → well_formed B
  ->
  Γ ⊢i A and B using i ->
  Γ ⊢i B and A using i.
Σ: Signature
A, B: Pattern
Γ: Theory
i: ProofInfo
well_formed A
→ well_formed B
  → Γ ⊢i A and B using i → Γ ⊢i B and A using i
Proof.
Σ: Signature
A, B: Pattern
Γ: Theory
i: ProofInfo
well_formed A
→ well_formed B
  → Γ ⊢i A and B using i → Γ ⊢i B and A using i
  intros WFA WFB H.
Σ: Signature
A, B: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A and B using i
Γ ⊢i B and A using i
  apply pf_conj_elim_r_meta in H as P1.
Σ: Signature
A, B: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A and B using i
P1: Γ ⊢i B using i
Γ ⊢i B and A using i
Σ: Signature
A, B: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A and B using i
well_formed A
Σ: Signature
A, B: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A and B using i
well_formed B
  apply pf_conj_elim_l_meta in H as P2.
Σ: Signature
A, B: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A and B using i
P1: Γ ⊢i B using i
P2: Γ ⊢i A using i
Γ ⊢i B and A using i
Σ: Signature
A, B: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A and B using i
P1: Γ ⊢i B using i
well_formed A
Σ: Signature
A, B: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A and B using i
P1: Γ ⊢i B using i
well_formed B
Σ: Signature
A, B: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A and B using i
well_formed A
Σ: Signature
A, B: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A and B using i
well_formed B all: try_wfauto2.
Σ: Signature
A, B: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A and B using i
P1: Γ ⊢i B using i
P2: Γ ⊢i A using i
Γ ⊢i B and A using i
  apply conj_intro_meta; assumption.
Defined.

Lemma MLGoal_applyMeta {Σ : Signature} Γ r r' i:
  Γ ⊢i (r' ---> r) using i ->
  forall l,
  mkMLGoal Σ Γ l r' i ->
  mkMLGoal Σ Γ l r i.
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Γ ⊢i r' ---> r using i
→ ∀ l : hypotheses,
    Γ Ⱶ
    l--------------------------------------
    r'
    using i
    
    → Γ Ⱶ
    l--------------------------------------
    r
    using i
    
Proof.
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Γ ⊢i r' ---> r using i
→ ∀ l : hypotheses,
    Γ Ⱶ
    l--------------------------------------
    r'
    using i
    
    → Γ Ⱶ
    l--------------------------------------
    r
    using i
    
  intros Himp l H.
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: Γ Ⱶ
l--------------------------------------
r'
using i

Γ Ⱶ
l--------------------------------------
r
using i

  unfold of_MLGoal in *.
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed
  (mlConclusion
     (Γ Ⱶ
      l--------------------------------------
      r'
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l--------------------------------------
           r'
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       l--------------------------------------
       r'
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l--------------------------------------
             r'
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l--------------------------------------
                r'
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             l--------------------------------------
             r'
             using i
             )
well_formed
  (mlConclusion
     (Γ Ⱶ
      l--------------------------------------
      r
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l--------------------------------------
           r
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       l--------------------------------------
       r
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l--------------------------------------
             r
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l--------------------------------------
                r
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             l--------------------------------------
             r
             using i
             ) simpl in *.
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r'
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
well_formed r
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp r (patterns_of l) using i
  intros wfr wfl.
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r'
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp r (patterns_of l) using i
  eapply prf_weaken_conclusion_iter_meta_meta.
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r'
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r'
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
well_formed ?g
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r'
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
well_formed r
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r'
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
Γ ⊢i ?g ---> r using i
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r'
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp ?g (patterns_of l) using i
  4: apply Himp.
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r'
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r'
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
well_formed r'
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r'
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
well_formed r
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r'
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp r' (patterns_of l) using i
  4: apply H.
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r'
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r'
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
well_formed r'
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r'
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
well_formed r
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r'
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
well_formed r'
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r'
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
  all: try assumption.
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r'
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
well_formed r'
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r'
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
well_formed r'
  1,2: pose proof (wfrr' := proved_impl_wf _ _ (proj1_sig Himp)); wf_auto2.
Defined.


Ltac _mlApplyMetaRaw t :=
  eapply (@MLGoal_applyMeta _ _ _ _ _ t).

Tactic Notation "mlApplyMetaRaw" uconstr(t) :=
  _mlApplyMetaRaw t.

Ltac2 _mlApplyMetaRaw (t : constr) :=
  eapply (@MLGoal_applyMeta _ _ _ _ _ $t).

Lemma MLGoal_left {Σ : Signature} Γ l x y i:
  mkMLGoal Σ Γ l x i ->
  mkMLGoal Σ Γ l (patt_or x y) i.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
Γ Ⱶ
l--------------------------------------
x
using i

→ Γ Ⱶ
l--------------------------------------
x or y
using i

Proof.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
Γ Ⱶ
l--------------------------------------
x
using i

→ Γ Ⱶ
l--------------------------------------
x or y
using i

  intros H.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: Γ Ⱶ
l--------------------------------------
x
using i

Γ Ⱶ
l--------------------------------------
x or y
using i

  unfold of_MLGoal in *.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed
  (mlConclusion
     (Γ Ⱶ
      l--------------------------------------
      x
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l--------------------------------------
           x
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       l--------------------------------------
       x
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l--------------------------------------
             x
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l--------------------------------------
                x
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             l--------------------------------------
             x
             using i
             )
well_formed
  (mlConclusion
     (Γ Ⱶ
      l--------------------------------------
      x or y
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l--------------------------------------
           x or y
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       l--------------------------------------
       x or y
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l--------------------------------------
             x or y
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l--------------------------------------
                x or y
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             l--------------------------------------
             x or y
             using i
             ) simpl in *.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
well_formed (x or y)
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp (x or y) (patterns_of l)
    using i
  intros wfxy wfl.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp (x or y) (patterns_of l) using i
  eapply prf_weaken_conclusion_iter_meta_meta.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed ?g
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed (x or y)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i ?g ---> x or y using i
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp ?g (patterns_of l) using i
  4: {
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i ?g ---> x or y using i useBasicReasoning.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i ?g ---> x or y using BasicReasoning apply disj_left_intro.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed x
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed y wf_auto2.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed y wf_auto2. }
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed x
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed (x or y)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp x (patterns_of l) using i
  {
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l) wf_auto2. }
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed x
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed (x or y)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp x (patterns_of l) using i
  {
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed x wf_auto2. }
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed (x or y)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp x (patterns_of l) using i
  {
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed (x or y) wf_auto2. }
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp x (patterns_of l) using i
  apply H.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed x
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
  {
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed x wf_auto2. }
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
  {
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l) assumption. }
Defined.

Lemma MLGoal_right {Σ : Signature} Γ l x y i:
  mkMLGoal Σ Γ l y i ->
  mkMLGoal Σ Γ l (patt_or x y) i.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
Γ Ⱶ
l--------------------------------------
y
using i

→ Γ Ⱶ
l--------------------------------------
x or y
using i

Proof.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
Γ Ⱶ
l--------------------------------------
y
using i

→ Γ Ⱶ
l--------------------------------------
x or y
using i

  intros H.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: Γ Ⱶ
l--------------------------------------
y
using i

Γ Ⱶ
l--------------------------------------
x or y
using i

  unfold of_MLGoal in *.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed
  (mlConclusion
     (Γ Ⱶ
      l--------------------------------------
      y
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l--------------------------------------
           y
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       l--------------------------------------
       y
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l--------------------------------------
             y
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l--------------------------------------
                y
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             l--------------------------------------
             y
             using i
             )
well_formed
  (mlConclusion
     (Γ Ⱶ
      l--------------------------------------
      x or y
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l--------------------------------------
           x or y
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       l--------------------------------------
       x or y
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l--------------------------------------
             x or y
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l--------------------------------------
                x or y
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             l--------------------------------------
             x or y
             using i
             ) simpl in *.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
well_formed (x or y)
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp (x or y) (patterns_of l)
    using i
  intros wfxy wfl.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp (x or y) (patterns_of l) using i
  eapply prf_weaken_conclusion_iter_meta_meta.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed ?g
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed (x or y)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i ?g ---> x or y using i
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp ?g (patterns_of l) using i
  4: {
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i ?g ---> x or y using i useBasicReasoning.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i ?g ---> x or y using BasicReasoning apply disj_right_intro.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed x
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed y wf_auto2.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed y wf_auto2. }
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed y
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed (x or y)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp y (patterns_of l) using i
  {
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l) wf_auto2. }
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed y
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed (x or y)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp y (patterns_of l) using i
  {
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed y wf_auto2. }
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed (x or y)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp y (patterns_of l) using i
  {
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed (x or y) wf_auto2. }
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp y (patterns_of l) using i
  apply H.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed y
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
  {
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed y wf_auto2. }
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
  {
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l) assumption. }
Defined.

Ltac mlLeft := _ensureProofMode; apply MLGoal_left.
Ltac mlRight := _ensureProofMode; apply MLGoal_right.

Local Example ex_mlLeft {Σ : Signature} Γ a:
  well_formed a ->
  Γ ⊢i a ---> (a or a)
  using BasicReasoning.
Σ: Signature
Γ: Theory
a: Pattern
well_formed a
→ Γ ⊢i a ---> a or a using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
a: Pattern
well_formed a
→ Γ ⊢i a ---> a or a using BasicReasoning
  intros wfa.
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ ⊢i a ---> a or a using BasicReasoning
  toMLGoal.
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
well_formed (a ---> a or a)
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ
a ---> a or a
using BasicReasoning

  {
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
well_formed (a ---> a or a) wf_auto2. }
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ
a ---> a or a
using BasicReasoning

  mlIntro "H0".
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ
"H0" ∶ a,
--------------------------------------
a or a
using BasicReasoning

  mlLeft.
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ
"H0" ∶ a,
--------------------------------------
a
using BasicReasoning

  mlExact "H0".
Defined.

Lemma MLGoal_applyMetaIn {Σ : Signature} Γ n r n' r' i:
  Γ ⊢i (r ---> r') using i ->
  forall l₁ l₂ g,
    mkMLGoal Σ Γ (l₁ ++ (mkNH _ n' r')::l₂) g i ->
    mkMLGoal Σ Γ (l₁ ++ (mkNH _ n r)::l₂ ) g i.
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Γ ⊢i r ---> r' using i
→ ∀ (l₁ l₂ : list named_hypothesis) (g : Pattern),
    Γ Ⱶ
    l₁ ++ (n' ∶ r') :: l₂--------------------------------------
    g
    using i
    
    → Γ Ⱶ
    l₁ ++ (n ∶ r) :: l₂--------------------------------------
    g
    using i
    
Proof.
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Γ ⊢i r ---> r' using i
→ ∀ (l₁ l₂ : list named_hypothesis) (g : Pattern),
    Γ Ⱶ
    l₁ ++ (n' ∶ r') :: l₂--------------------------------------
    g
    using i
    
    → Γ Ⱶ
    l₁ ++ (n ∶ r) :: l₂--------------------------------------
    g
    using i
    
  intros Himp l₁ l₂ g H.
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
H: Γ Ⱶ
l₁ ++ (n' ∶ r') :: l₂--------------------------------------
g
using i

Γ Ⱶ
l₁ ++ (n ∶ r) :: l₂--------------------------------------
g
using i

  unfold of_MLGoal in *.
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
H: well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (n' ∶ r') :: l₂--------------------------------------
      g
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l₁ ++ (n' ∶ r') :: l₂--------------------------------------
           g
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       l₁ ++ (n' ∶ r') :: l₂--------------------------------------
       g
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l₁ ++ (n' ∶ r') :: l₂--------------------------------------
             g
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l₁ ++ (n' ∶ r') :: l₂--------------------------------------
                g
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             l₁ ++ (n' ∶ r') :: l₂--------------------------------------
             g
             using i
             )
well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (n ∶ r) :: l₂--------------------------------------
      g
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l₁ ++ (n ∶ r) :: l₂--------------------------------------
           g
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       l₁ ++ (n ∶ r) :: l₂--------------------------------------
       g
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l₁ ++ (n ∶ r) :: l₂--------------------------------------
             g
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l₁ ++ (n ∶ r) :: l₂--------------------------------------
                g
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             l₁ ++ (n ∶ r) :: l₂--------------------------------------
             g
             using i
             ) simpl in *.
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
H: well_formed g
→ Pattern.wf (patterns_of (l₁ ++ (n' ∶ r') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l₁ ++ (n' ∶ r') :: l₂))
    using i
well_formed g
→ Pattern.wf (patterns_of (l₁ ++ (n ∶ r) :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l₁ ++ (n ∶ r) :: l₂)) using i
  intros wfg Hwf.
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
H: well_formed g
→ Pattern.wf (patterns_of (l₁ ++ (n' ∶ r') :: l₂))
  → Γ
    ⊢i foldr patt_imp g
         (patterns_of (l₁ ++ (n' ∶ r') :: l₂))
    using i
wfg: well_formed g
Hwf: Pattern.wf (patterns_of (l₁ ++ (n ∶ r) :: l₂))
Γ
⊢i foldr patt_imp g
     (patterns_of (l₁ ++ (n ∶ r) :: l₂)) using i
  specialize (H wfg).
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
H: Pattern.wf (patterns_of (l₁ ++ (n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (patterns_of (l₁ ++ (n' ∶ r') :: l₂))
  using i
wfg: well_formed g
Hwf: Pattern.wf (patterns_of (l₁ ++ (n ∶ r) :: l₂))
Γ
⊢i foldr patt_imp g
     (patterns_of (l₁ ++ (n ∶ r) :: l₂)) using i
  unfold patterns_of in *.
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
H: Pattern.wf (map nh_patt (l₁ ++ (n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt (l₁ ++ (n' ∶ r') :: l₂))
  using i
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
Γ
⊢i foldr patt_imp g
     (map nh_patt (l₁ ++ (n ∶ r) :: l₂)) using i
  rewrite map_app in H.
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Γ
⊢i foldr patt_imp g
     (map nh_patt (l₁ ++ (n ∶ r) :: l₂)) using i
  rewrite map_app.
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Γ
⊢i foldr patt_imp g
     (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
using i
  eapply prf_strenghten_premise_iter_meta_meta.
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Pattern.wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l₂)
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
well_formed ?h
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
well_formed (nh_patt (n ∶ r))
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
well_formed g
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Γ ⊢i nh_patt (n ∶ r) ---> ?h using i
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Γ
⊢i foldr patt_imp g
     (map nh_patt l₁ ++
      ?h
      :: (fix map (l : list named_hypothesis) :
              list Pattern :=
            match l with
            | [] => []
            | a :: t => nh_patt a :: map t
            end) l₂) using i
  6: apply Himp.
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Pattern.wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l₂)
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
well_formed r'
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
well_formed (nh_patt (n ∶ r))
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
well_formed g
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Γ
⊢i foldr patt_imp g
     (map nh_patt l₁ ++
      r'
      :: (fix map (l : list named_hypothesis) :
              list Pattern :=
            match l with
            | [] => []
            | a :: t => nh_patt a :: map t
            end) l₂) using i
  6: apply H.
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Pattern.wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l₂)
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
well_formed r'
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
well_formed (nh_patt (n ∶ r))
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
well_formed g
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
  all: rewrite map_app in Hwf.
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
Pattern.wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l₂)
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
well_formed r'
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
well_formed (nh_patt (n ∶ r))
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
well_formed g
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
  {
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
Pattern.wf (map nh_patt l₁) abstract (apply wfapp_proj_1 in Hwf; exact Hwf). }
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l₂)
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
well_formed r'
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
well_formed (nh_patt (n ∶ r))
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
well_formed g
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
  {
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
Pattern.wf
  ((fix map (l : list named_hypothesis) :
        list Pattern :=
      match l with
      | [] => []
      | a :: t => nh_patt a :: map t
      end) l₂) abstract (apply wfl₁hl₂_proj_l₂ in Hwf; exact Hwf). }
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
well_formed r'
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
well_formed (nh_patt (n ∶ r))
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
well_formed g
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
  {
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
well_formed r' abstract (pose proof (Himp' := proj1_sig Himp); apply proved_impl_wf in Himp'; wf_auto2). }
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
well_formed (nh_patt (n ∶ r))
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
well_formed g
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
  {
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
well_formed (nh_patt (n ∶ r)) abstract (apply wfl₁hl₂_proj_h in Hwf; exact Hwf). }
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
well_formed g
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
  {
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
well_formed g exact wfg. }
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
  {
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
→ Γ
  ⊢i foldr patt_imp g
       (map nh_patt l₁ ++
        map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
Pattern.wf
  (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) abstract(
      pose proof (wfapp_proj_1 _ _ Hwf);
      pose proof (wfl₁hl₂_proj_l₂ _ _ _ Hwf);
      pose proof (wfl₁hl₂_proj_h _ _ _ Hwf);
      unfold Pattern.wf;
      rewrite map_app;
      rewrite foldr_app;
      simpl;
      pose proof (Himp' := proj1_sig Himp);
      apply proved_impl_wf in Himp';
      apply well_formed_imp_proj2 in Himp';
      rewrite Himp';
      simpl;
      unfold Pattern.wf in H1;
      rewrite H1;
      exact H0
    ).
 }
Defined.

Ltac _mlApplyMetaRawIn t name :=
  eapply cast_proof_ml_hyps;
  f_equal;
  _mlReshapeHypsByName name;
  eapply (@MLGoal_applyMetaIn _ _ _ _ name _ _ t);
  _mlReshapeHypsBack.

Ltac2 _mlApplyMetaRawIn (t : constr) (name : constr) :=
  ltac1:(t' name' |- _mlApplyMetaRawIn t' name')
    (Ltac1.of_constr t)
    (Ltac1.of_constr name)
.

Tactic Notation "mlApplyMetaRaw" uconstr(t) "in" constr(name) :=
  _mlApplyMetaRawIn t name.


Local Example Private_ex_mlApplyMetaRawIn {Σ : Signature} Γ p q:
  well_formed p ->
  well_formed q ->
  Γ ⊢i p ---> (p or q)
  using BasicReasoning.
Σ: Signature
Γ: Theory
p, q: Pattern
well_formed p
→ well_formed q
  → Γ ⊢i p ---> p or q using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
p, q: Pattern
well_formed p
→ well_formed q
  → Γ ⊢i p ---> p or q using BasicReasoning
  intros wfp wfq.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ ⊢i p ---> p or q using BasicReasoning
  toMLGoal.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
well_formed (p ---> p or q)
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
p ---> p or q
using BasicReasoning

  {
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
well_formed (p ---> p or q) wf_auto2. }
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
p ---> p or q
using BasicReasoning

  mlIntro "H0".
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
"H0" ∶ p,
--------------------------------------
p or q
using BasicReasoning

  mlApplyMetaRaw (disj_left_intro Γ p q ltac:(wf_auto2) ltac:(wf_auto2)) in "H0".
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
"H0" ∶ p or q,
--------------------------------------
p or q
using BasicReasoning

  mlExact "H0".
Defined.

Ltac2 rec applyRec (f : constr) (xs : constr list) : constr option :=
  match xs with
  | [] => Some f
  | y::ys =>
    lazy_match! Constr.type f with
    | (forall _ : ?t, _) =>
      Control.plus (fun () => applyRec constr:($f $y) ys) (fun _ => None)
    | _ => None
    end
  end.

Ltac2 Eval (applyRec constr:(Nat.add) [constr:(1);constr:(2)]).
- : constr option = Some (constr:(1 + 2))

(*
  All thic complicated code is here only for one reason:
  I want to be able to first run the tactic with all the parameters
  inferred or question marked, which results in another goal.
  And then I want to handle the subgoals generated by the filling-in
  underscores / question marks.
  In particular, I want the proof mode goals to be generated first,
  and the other, uninteresting goals, next.
*)
Ltac2 rec fillWithUnderscoresAndCall
  (tac : constr -> unit) (t : constr) (args : constr list) :=
  (*
  Message.print (
    Message.concat
      (Message.of_string "fillWithUnderscoresAndCall: t = ")
      (Message.of_constr t)
  );
  Message.print (
    Message.concat
      (Message.of_string "fillWithUnderscoresAndCall: args = ")
      (List.fold_right (Message.concat) (Message.of_string "") (List.map Message.of_constr args))
  );
  *)
  let cont := (fun () =>
    lazy_match! Constr.type t with
    | (?t' -> ?t's) =>
      lazy_match! goal with
      | [|- ?g] =>
        let h := Fresh.in_goal ident:(h) in
        assert(h : $t' -> $g) > [(
          let pftprime := Fresh.in_goal ident:(pftprime) in
          intro $pftprime;
          let new_t := open_constr:($t ltac2:(Notations.exact0 false (fun () => Control.hyp (pftprime)))) in
          fillWithUnderscoresAndCall tac new_t args;
          Std.clear [pftprime]
        )|(apply &h)
        ]
      end
    | (forall _ : _, _) => fillWithUnderscoresAndCall tac open_constr:($t _) args
    | ?remainder => throw (Invalid_argument (Some (Message.concat (Message.concat (Message.of_string "Remainder type: ") (Message.of_constr remainder)) (Message.concat (Message.of_string ", of term") (Message.of_constr t)))))
    end
  ) in
  match (applyRec t args) with
  | None =>
    (* Cannot apply [t] to [args] => continue *)
    cont ()
  | Some result =>
    (* Can apply [to] to [args], *)
    lazy_match! Constr.type result with
    | (forall _ : _, _) =>
      (* but result would still accept an argument => continue *)
      cont ()
    | _ =>
      (* and nothing more can be applied to the result => we are done *)
      tac result
    end
  end
.

(*
  We have this double-primed version because we want to be able
  to feed it the proof before feeding it the ProofInfoLe.
*)
Lemma useGenericReasoning''  {Σ : Signature} (Γ : Theory) (ϕ : Pattern) i' i:
  Γ ⊢i ϕ using i' ->
  (ProofInfoLe i' i) ->
  Γ ⊢i ϕ using i.
Σ: Signature
Γ: Theory
ϕ: Pattern
i', i: ProofInfo
Γ ⊢i ϕ using i' → ProofInfoLe i' i → Γ ⊢i ϕ using i
Proof.
Σ: Signature
Γ: Theory
ϕ: Pattern
i', i: ProofInfo
Γ ⊢i ϕ using i' → ProofInfoLe i' i → Γ ⊢i ϕ using i
  intros H pile.
Σ: Signature
Γ: Theory
ϕ: Pattern
i', i: ProofInfo
H: Γ ⊢i ϕ using i'
pile: ProofInfoLe i' i
Γ ⊢i ϕ using i
  eapply useGenericReasoning.
Σ: Signature
Γ: Theory
ϕ: Pattern
i', i: ProofInfo
H: Γ ⊢i ϕ using i'
pile: ProofInfoLe i' i
ProofInfoLe ?i' i
Σ: Signature
Γ: Theory
ϕ: Pattern
i', i: ProofInfo
H: Γ ⊢i ϕ using i'
pile: ProofInfoLe i' i
Γ ⊢i ϕ using ?i'
  {
Σ: Signature
Γ: Theory
ϕ: Pattern
i', i: ProofInfo
H: Γ ⊢i ϕ using i'
pile: ProofInfoLe i' i
ProofInfoLe ?i' i apply pile. }
Σ: Signature
Γ: Theory
ϕ: Pattern
i', i: ProofInfo
H: Γ ⊢i ϕ using i'
pile: ProofInfoLe i' i
Γ ⊢i ϕ using i'
  apply H.
Defined.

Ltac2 _callCompletedAndCast (t : constr) (tac : constr -> unit) :=
  let tac' := (fun (t' : constr) =>
    let tcast := open_constr:(@useGenericReasoning'' _ _ _ _ _ $t') in
    fillWithUnderscoresAndCall tac tcast []
  ) in
  fillWithUnderscoresAndCall tac' t []
.

Ltac2 try_solve_pile_basic () :=
  Control.enter (fun () =>
    lazy_match! goal with
    | [ |- (@ProofInfoLe _ _ _)] =>
        try (solve
          [ apply pile_any
          | apply pile_refl
          | apply pile_basic_generic
       ])
    | [|- _] => ()
    end
  )
.

Ltac2 try_wfa () :=
  Control.enter (fun () =>
    let wfa := (fun p =>
      if (Constr.has_evar p) then
        ()
      else
        ltac1:(try_wfauto2)
    ) in
    lazy_match! goal with
    | [|- well_formed ?p = true] => wfa p
    | [|- is_true (well_formed ?p) ] => wfa p
    | [|- Pattern.wf ?l = true] => wfa l
    | [|- is_true (Pattern.wf ?l) ] => wfa l
    | [|- _] => ()
    end
  )
.

Ltac2 mlApplyMeta (t : constr) :=
  _callCompletedAndCast t _mlApplyMetaRaw ;
  try_solve_pile_basic ();
  try_wfa ()
.

Ltac2 mlApplyMetaIn (t : constr) (name : constr) :=
  _callCompletedAndCast t (fun t =>
    _mlApplyMetaRawIn t name
  );
  try_solve_pile_basic ();
  try_wfa ()
.

Ltac _mlApplyMeta t :=
  _ensureProofMode;
  let ff := ltac2:(t' |- mlApplyMeta (Option.get (Ltac1.to_constr(t')))) in
  ff t.

Ltac _mlApplyMetaIn t name :=
  _ensureProofMode;
  let ff := ltac2:(t' name' |- mlApplyMetaIn (Option.get (Ltac1.to_constr(t'))) (Option.get (Ltac1.to_constr(name')))) in
  ff t name
.

Tactic Notation "mlApplyMeta" constr(t) :=
  _mlApplyMeta t.

Tactic Notation "mlApplyMeta" constr(t) "in" constr(name) :=
  _mlApplyMetaIn t name
.


Lemma MLGoal_destructAnd {Σ : Signature} Γ g l₁ l₂ nx x ny y nxy i:
    mkMLGoal Σ Γ (l₁ ++ (mkNH _ nx x)::(mkNH _ ny y)::l₂ ) g i ->
    mkMLGoal Σ Γ (l₁ ++ (mkNH _ nxy (x and y))::l₂) g i.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

→ Γ Ⱶ
l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
g
using i

Proof.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

→ Γ Ⱶ
l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
g
using i

  intros H.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

Γ Ⱶ
l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
g
using i

  unfold of_MLGoal.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
      g
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
           g
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
       g
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
             g
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
                g
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
             g
             using i
             ) intros wfg Hwf.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed
(mlConclusion
(Γ Ⱶ
l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
g
using i
))
Hwf: Pattern.wf
(patterns_of
(mlHypotheses
(Γ Ⱶ
l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
g
using i
)))
mlTheory
  (Γ Ⱶ
   l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
   g
   using i
   )
⊢i foldr patt_imp
     (mlConclusion
        (Γ Ⱶ
         l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
         g
         using i
         ))
     (patterns_of
        (mlHypotheses
           (Γ Ⱶ
            l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
            g
            using i
            )))
using mlInfo
        (Γ Ⱶ
         l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
         g
         using i
         ) pose proof (wfg' := wfg).
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed
(mlConclusion
(Γ Ⱶ
l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
g
using i
))
Hwf: Pattern.wf
(patterns_of
(mlHypotheses
(Γ Ⱶ
l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
g
using i
)))
wfg': well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
      g
      using i
      ))
mlTheory
  (Γ Ⱶ
   l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
   g
   using i
   )
⊢i foldr patt_imp
     (mlConclusion
        (Γ Ⱶ
         l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
         g
         using i
         ))
     (patterns_of
        (mlHypotheses
           (Γ Ⱶ
            l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
            g
            using i
            )))
using mlInfo
        (Γ Ⱶ
         l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
         g
         using i
         ) pose proof (Hwf' := Hwf).
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed
(mlConclusion
(Γ Ⱶ
l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
g
using i
))
Hwf: Pattern.wf
(patterns_of
(mlHypotheses
(Γ Ⱶ
l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
g
using i
)))
wfg': well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
      g
      using i
      ))
Hwf': Pattern.wf
  (patterns_of
     (mlHypotheses
        (Γ Ⱶ
         l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
         g
         using i
         )))
mlTheory
  (Γ Ⱶ
   l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
   g
   using i
   )
⊢i foldr patt_imp
     (mlConclusion
        (Γ Ⱶ
         l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
         g
         using i
         ))
     (patterns_of
        (mlHypotheses
           (Γ Ⱶ
            l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
            g
            using i
            )))
using mlInfo
        (Γ Ⱶ
         l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
         g
         using i
         )
  revert wfg' Hwf'.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed
(mlConclusion
(Γ Ⱶ
l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
g
using i
))
Hwf: Pattern.wf
(patterns_of
(mlHypotheses
(Γ Ⱶ
l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
g
using i
)))
well_formed
  (mlConclusion
     (Γ Ⱶ
      l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
      g
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
           g
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
       g
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
             g
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
                g
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
             g
             using i
             )
  cut (of_MLGoal (mkMLGoal Σ Γ (l₁ ++ (mkNH _ nxy (x and y))::l₂ ) g i)).
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed
(mlConclusion
(Γ Ⱶ
l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
g
using i
))
Hwf: Pattern.wf
(patterns_of
(mlHypotheses
(Γ Ⱶ
l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
g
using i
)))
Γ Ⱶ
l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
g
using i

→ well_formed
    (mlConclusion
       (Γ Ⱶ
        l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
        g
        using i
        ))
  → Pattern.wf
      (patterns_of
         (mlHypotheses
            (Γ Ⱶ
             l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
             g
             using i
             )))
    → mlTheory
        (Γ Ⱶ
         l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
         g
         using i
         )
      ⊢i foldr patt_imp
           (mlConclusion
              (Γ Ⱶ
               l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
               g
               using i
               ))
           (patterns_of
              (mlHypotheses
                 (Γ Ⱶ
                  l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
                  g
                  using i
                  )))
      using mlInfo
              (Γ Ⱶ
               l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
               g
               using i
               )
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed
(mlConclusion
(Γ Ⱶ
l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
g
using i
))
Hwf: Pattern.wf
(patterns_of
(mlHypotheses
(Γ Ⱶ
l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
g
using i
)))
Γ Ⱶ
l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
g
using i

  {
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed
(mlConclusion
(Γ Ⱶ
l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
g
using i
))
Hwf: Pattern.wf
(patterns_of
(mlHypotheses
(Γ Ⱶ
l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
g
using i
)))
Γ Ⱶ
l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
g
using i

→ well_formed
    (mlConclusion
       (Γ Ⱶ
        l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
        g
        using i
        ))
  → Pattern.wf
      (patterns_of
         (mlHypotheses
            (Γ Ⱶ
             l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
             g
             using i
             )))
    → mlTheory
        (Γ Ⱶ
         l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
         g
         using i
         )
      ⊢i foldr patt_imp
           (mlConclusion
              (Γ Ⱶ
               l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
               g
               using i
               ))
           (patterns_of
              (mlHypotheses
                 (Γ Ⱶ
                  l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
                  g
                  using i
                  )))
      using mlInfo
              (Γ Ⱶ
               l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
               g
               using i
               ) auto. }
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed
(mlConclusion
(Γ Ⱶ
l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
g
using i
))
Hwf: Pattern.wf
(patterns_of
(mlHypotheses
(Γ Ⱶ
l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
g
using i
)))
Γ Ⱶ
l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
g
using i

  simpl in wfg, Hwf.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf: Pattern.wf (patterns_of (l₁ ++ (nxy ∶ x and y) :: l₂))
Γ Ⱶ
l₁ ++ (nxy ∶ x and y) :: l₂--------------------------------------
g
using i


  mlAssert (ny : y) using first (length (l₁ ++ [mkNH _ nxy (x and y)])).
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf: Pattern.wf (patterns_of (l₁ ++ (nxy ∶ x and y) :: l₂))
l1: list named_hypothesis
Heql1: l1 =
take (length (l₁ ++ (nxy ∶ x and y,
                     )))
  (l₁ ++ (nxy ∶ x and y) :: l₂)
l2: list named_hypothesis
Heql2: l2 =
drop (length (l₁ ++ (nxy ∶ x and y,
                     )))
  (l₁ ++ (nxy ∶ x and y) :: l₂)
well_formed y
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf: Pattern.wf
  (patterns_of (l₁ ++ (nxy ∶ x and y) :: l₂))
Hwf0: well_formed y
Γ Ⱶ
take (length (l₁ ++ (nxy ∶ x and y,
                     ))) 
  (l₁ ++ (nxy ∶ x and y) :: l₂)--------------------------------------
y
using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf: Pattern.wf
  (patterns_of (l₁ ++ (nxy ∶ x and y) :: l₂))
Hwf0: well_formed y
Γ Ⱶ
take (length (l₁ ++ (nxy ∶ x and y,
                     ))) 
  (l₁ ++ (nxy ∶ x and y) :: l₂) ++
(ny ∶ y)
:: drop (length (l₁ ++ (nxy ∶ x and y,
                       )))
     (l₁ ++ (nxy ∶ x and y) :: l₂)--------------------------------------
g
using i


  all: unfold patterns_of in Hwf; rewrite map_app in Hwf.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
l1: list named_hypothesis
Heql1: l1 =
take (length (l₁ ++ (nxy ∶ x and y,
                     )))
  (l₁ ++ (nxy ∶ x and y) :: l₂)
l2: list named_hypothesis
Heql2: l2 =
drop (length (l₁ ++ (nxy ∶ x and y,
                     )))
  (l₁ ++ (nxy ∶ x and y) :: l₂)
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
well_formed y
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Γ Ⱶ
take (length (l₁ ++ (nxy ∶ x and y,
                     ))) 
  (l₁ ++ (nxy ∶ x and y) :: l₂)--------------------------------------
y
using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Γ Ⱶ
take (length (l₁ ++ (nxy ∶ x and y,
                     ))) 
  (l₁ ++ (nxy ∶ x and y) :: l₂) ++
(ny ∶ y)
:: drop (length (l₁ ++ (nxy ∶ x and y,
                       )))
     (l₁ ++ (nxy ∶ x and y) :: l₂)--------------------------------------
g
using i


  {
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
l1: list named_hypothesis
Heql1: l1 =
take (length (l₁ ++ (nxy ∶ x and y,
                     )))
  (l₁ ++ (nxy ∶ x and y) :: l₂)
l2: list named_hypothesis
Heql2: l2 =
drop (length (l₁ ++ (nxy ∶ x and y,
                     )))
  (l₁ ++ (nxy ∶ x and y) :: l₂)
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
well_formed y abstract (
      apply wfapp_proj_2 in Hwf;
      unfold Pattern.wf in Hwf;
      simpl in Hwf;
      apply andb_prop in Hwf;
      destruct Hwf as [wfxy _];
      wf_auto2
    ).
  }
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Γ Ⱶ
take (length (l₁ ++ (nxy ∶ x and y,
                     ))) (l₁ ++ (nxy ∶ x and y) :: l₂)--------------------------------------
y
using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Γ Ⱶ
take (length (l₁ ++ (nxy ∶ x and y,
                     ))) 
  (l₁ ++ (nxy ∶ x and y) :: l₂) ++
(ny ∶ y)
:: drop (length (l₁ ++ (nxy ∶ x and y,
                        )))
     (l₁ ++ (nxy ∶ x and y) :: l₂)--------------------------------------
g
using i

  {
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Γ Ⱶ
take (length (l₁ ++ (nxy ∶ x and y,
                     ))) (l₁ ++ (nxy ∶ x and y) :: l₂)--------------------------------------
y
using i

    eapply cast_proof_ml_hyps.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
patterns_of ?hyps =
patterns_of
  (take (length (l₁ ++ (nxy ∶ x and y,
                        )))
     (l₁ ++ (nxy ∶ x and y) :: l₂))
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Γ Ⱶ
?hyps--------------------------------------
y
using i

    {
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
patterns_of ?hyps =
patterns_of
  (take (length (l₁ ++ (nxy ∶ x and y,
                        )))
     (l₁ ++ (nxy ∶ x and y) :: l₂)) replace (l₁ ++ (mkNH _ nxy (x and y)) :: l₂) with ((l₁ ++ [mkNH _ nxy (x and y)]) ++ l₂).
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
patterns_of ?hyps =
patterns_of
  (take (length (l₁ ++ (nxy ∶ x and y,
                        )))
     ((l₁ ++ (nxy ∶ x and y,
              )) ++ l₂))
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
(l₁ ++ (nxy ∶ x and y,
        )) ++ l₂ = l₁ ++ (nxy ∶ x and y) :: l₂
      2: {
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
(l₁ ++ (nxy ∶ x and y,
        )) ++ l₂ = l₁ ++ (nxy ∶ x and y) :: l₂ rewrite -app_assoc.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
l₁ ++ (nxy ∶ x and y,
       ) ++ l₂ = l₁ ++ (nxy ∶ x and y) :: l₂ reflexivity. }
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
patterns_of ?hyps =
patterns_of
  (take (length (l₁ ++ (nxy ∶ x and y,
                        )))
     ((l₁ ++ (nxy ∶ x and y,
              )) ++ l₂))
      rewrite take_app.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
patterns_of ?hyps =
patterns_of (l₁ ++ (nxy ∶ x and y,
                    ))
      reflexivity.
    }
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Γ Ⱶ
l₁ ++ (nxy ∶ x and y,
       )--------------------------------------
y
using i

    assert (well_formed x).
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
well_formed x
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
H0: well_formed x
Γ Ⱶ
l₁ ++ (nxy ∶ x and y,
       )--------------------------------------
y
using i

    {
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
well_formed x
      abstract (
        apply wfapp_proj_2 in Hwf;
        unfold Pattern.wf in Hwf;
        simpl in Hwf;
        apply andb_prop in Hwf as [wfxy _];
        wf_auto2
      ).
    }
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
H0: well_formed x
Γ Ⱶ
l₁ ++ (nxy ∶ x and y,
       )--------------------------------------
y
using i


    mlApplyMeta pf_conj_elim_r.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
H0: well_formed x
Γ Ⱶ
l₁ ++ (nxy ∶ x and y,
       )--------------------------------------
?A and y
using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
H0: well_formed x
h: well_formed ?A
→ Γ Ⱶ
l₁ ++ (nxy ∶ x and y,
       )--------------------------------------
y
using i

well_formed ?A
    apply MLGoal_exactn.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
H0: well_formed x
h: well_formed x
→ Γ Ⱶ
l₁ ++ (nxy ∶ x and y,
       )--------------------------------------
y
using i

well_formed x
    wf_auto2.
  }
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Γ Ⱶ
take (length (l₁ ++ (nxy ∶ x and y,
                     ))) (l₁ ++ (nxy ∶ x and y) :: l₂) ++
(ny ∶ y)
:: drop (length (l₁ ++ (nxy ∶ x and y,
                        )))
     (l₁ ++ (nxy ∶ x and y) :: l₂)--------------------------------------
g
using i


  eapply cast_proof_ml_hyps.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
patterns_of ?hyps =
patterns_of
  (take (length (l₁ ++ (nxy ∶ x and y,
                        )))
     (l₁ ++ (nxy ∶ x and y) :: l₂) ++
   (ny ∶ y)
   :: drop (length (l₁ ++ (nxy ∶ x and y,
                           )))
        (l₁ ++ (nxy ∶ x and y) :: l₂))
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Γ Ⱶ
?hyps--------------------------------------
g
using i

  {
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
patterns_of ?hyps =
patterns_of
  (take (length (l₁ ++ (nxy ∶ x and y,
                        )))
     (l₁ ++ (nxy ∶ x and y) :: l₂) ++
   (ny ∶ y)
   :: drop (length (l₁ ++ (nxy ∶ x and y,
                           )))
        (l₁ ++ (nxy ∶ x and y) :: l₂))
    replace (l₁ ++ (mkNH _ nxy (x and y)) :: l₂) with ((l₁ ++ [mkNH _ nxy (x and y)]) ++ l₂).
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
patterns_of ?hyps =
patterns_of
  (take (length (l₁ ++ (nxy ∶ x and y,
                        )))
     ((l₁ ++ (nxy ∶ x and y,
              )) ++ l₂) ++
   (ny ∶ y)
   :: drop (length (l₁ ++ (nxy ∶ x and y,
                           )))
        ((l₁ ++ (nxy ∶ x and y,
                 )) ++ l₂))
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
(l₁ ++ (nxy ∶ x and y,
        )) ++ l₂ = l₁ ++ (nxy ∶ x and y) :: l₂
    2: {
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
(l₁ ++ (nxy ∶ x and y,
        )) ++ l₂ = l₁ ++ (nxy ∶ x and y) :: l₂ rewrite -app_assoc.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
l₁ ++ (nxy ∶ x and y,
       ) ++ l₂ = l₁ ++ (nxy ∶ x and y) :: l₂ reflexivity. }
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
patterns_of ?hyps =
patterns_of
  (take (length (l₁ ++ (nxy ∶ x and y,
                        )))
     ((l₁ ++ (nxy ∶ x and y,
              )) ++ l₂) ++
   (ny ∶ y)
   :: drop (length (l₁ ++ (nxy ∶ x and y,
                           )))
        ((l₁ ++ (nxy ∶ x and y,
                 )) ++ l₂))
    rewrite take_app.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
patterns_of ?hyps =
patterns_of
  ((l₁ ++ (nxy ∶ x and y,
           )) ++
   (ny ∶ y)
   :: drop (length (l₁ ++ (nxy ∶ x and y,
                           )))
        ((l₁ ++ (nxy ∶ x and y,
                 )) ++ l₂)) rewrite drop_app.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
patterns_of ?hyps =
patterns_of
  ((l₁ ++ (nxy ∶ x and y,
           )) ++ (ny ∶ y) :: l₂) reflexivity.
  }
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Γ Ⱶ
(l₁ ++ (nxy ∶ x and y,
        )) ++ (ny ∶ y) :: l₂--------------------------------------
g
using i


  mlAssert (nx : x) using first (length (l₁ ++ [mkNH _ nxy (x and y)])).
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
l1: list named_hypothesis
Heql1: l1 =
take (length (l₁ ++ (nxy ∶ x and y,
                     )))
  ((l₁ ++ (nxy ∶ x and y,
           )) ++ (ny ∶ y) :: l₂)
l2: list named_hypothesis
Heql2: l2 =
drop (length (l₁ ++ (nxy ∶ x and y,
                     )))
  ((l₁ ++ (nxy ∶ x and y,
           )) ++ (ny ∶ y) :: l₂)
well_formed x
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
Γ Ⱶ
take (length (l₁ ++ (nxy ∶ x and y,
                     )))
  ((l₁ ++ (nxy ∶ x and y,
           )) ++ (ny ∶ y) :: l₂)--------------------------------------
x
using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
Γ Ⱶ
take (length (l₁ ++ (nxy ∶ x and y,
                     )))
  ((l₁ ++ (nxy ∶ x and y,
           )) ++ (ny ∶ y) :: l₂) ++
(nx ∶ x)
:: drop (length (l₁ ++ (nxy ∶ x and y,
                        )))
     ((l₁ ++ (nxy ∶ x and y,
              )) ++ (ny ∶ y) :: l₂)--------------------------------------
g
using i

  {
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
l1: list named_hypothesis
Heql1: l1 =
take (length (l₁ ++ (nxy ∶ x and y,
                     )))
  ((l₁ ++ (nxy ∶ x and y,
           )) ++ (ny ∶ y) :: l₂)
l2: list named_hypothesis
Heql2: l2 =
drop (length (l₁ ++ (nxy ∶ x and y,
                     )))
  ((l₁ ++ (nxy ∶ x and y,
           )) ++ (ny ∶ y) :: l₂)
well_formed x abstract (
      apply wfapp_proj_2 in Hwf;
      unfold Pattern.wf in Hwf;
      simpl in Hwf;
      apply andb_prop in Hwf;
      destruct Hwf as [wfxy _];
      wf_auto2
    ).
  }
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
Γ Ⱶ
take (length (l₁ ++ (nxy ∶ x and y,
                     )))
  ((l₁ ++ (nxy ∶ x and y,
           )) ++ (ny ∶ y) :: l₂)--------------------------------------
x
using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
Γ Ⱶ
take (length (l₁ ++ (nxy ∶ x and y,
                     )))
  ((l₁ ++ (nxy ∶ x and y,
           )) ++ (ny ∶ y) :: l₂) ++
(nx ∶ x)
:: drop (length (l₁ ++ (nxy ∶ x and y,
                        )))
     ((l₁ ++ (nxy ∶ x and y,
              )) ++ (ny ∶ y) :: l₂)--------------------------------------
g
using i

  {
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
Γ Ⱶ
take (length (l₁ ++ (nxy ∶ x and y,
                     )))
  ((l₁ ++ (nxy ∶ x and y,
           )) ++ (ny ∶ y) :: l₂)--------------------------------------
x
using i

    eapply cast_proof_ml_hyps.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
patterns_of ?hyps =
patterns_of
  (take (length (l₁ ++ (nxy ∶ x and y,
                        )))
     ((l₁ ++ (nxy ∶ x and y,
              )) ++ (ny ∶ y) :: l₂))
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
Γ Ⱶ
?hyps--------------------------------------
x
using i

    {
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
patterns_of ?hyps =
patterns_of
  (take (length (l₁ ++ (nxy ∶ x and y,
                        )))
     ((l₁ ++ (nxy ∶ x and y,
              )) ++ (ny ∶ y) :: l₂))
      replace (l₁ ++ (mkNH _ nxy (x and y)) :: l₂) with ((l₁++ [mkNH _ nxy (x and y)]) ++ l₂).
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
patterns_of ?hyps =
patterns_of
  (take (length (l₁ ++ (nxy ∶ x and y,
                        )))
     ((l₁ ++ (nxy ∶ x and y,
              )) ++ (ny ∶ y) :: l₂))
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
(l₁ ++ (nxy ∶ x and y,
        )) ++ l₂ = l₁ ++ (nxy ∶ x and y) :: l₂
      2: {
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
(l₁ ++ (nxy ∶ x and y,
        )) ++ l₂ = l₁ ++ (nxy ∶ x and y) :: l₂ rewrite -app_assoc.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
l₁ ++ (nxy ∶ x and y,
       ) ++ l₂ = l₁ ++ (nxy ∶ x and y) :: l₂ reflexivity. }
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
patterns_of ?hyps =
patterns_of
  (take (length (l₁ ++ (nxy ∶ x and y,
                        )))
     ((l₁ ++ (nxy ∶ x and y,
              )) ++ (ny ∶ y) :: l₂))
      rewrite take_app.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
patterns_of ?hyps =
patterns_of (l₁ ++ (nxy ∶ x and y,
                    ))
      reflexivity.
    }
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
Γ Ⱶ
l₁ ++ (nxy ∶ x and y,
       )--------------------------------------
x
using i

    assert (well_formed x).
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
well_formed x
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1, H0: well_formed x
Γ Ⱶ
l₁ ++ (nxy ∶ x and y,
       )--------------------------------------
x
using i

    {
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
well_formed x
      abstract (
        apply wfapp_proj_2 in Hwf;
        unfold Pattern.wf in Hwf;
        simpl in Hwf;
        apply andb_prop in Hwf as [wfxy _];
        wf_auto2
      ).
    }
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1, H0: well_formed x
Γ Ⱶ
l₁ ++ (nxy ∶ x and y,
       )--------------------------------------
x
using i

    mlApplyMeta pf_conj_elim_l.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1, H0: well_formed x
Γ Ⱶ
l₁ ++ (nxy ∶ x and y,
       )--------------------------------------
x and ?B
using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1, H0: well_formed x
h: well_formed ?B
→ Γ Ⱶ
l₁ ++ (nxy ∶ x and y,
       )--------------------------------------
x
using i

well_formed ?B
    apply MLGoal_exactn.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1, H0: well_formed x
h: well_formed y
→ Γ Ⱶ
l₁ ++ (nxy ∶ x and y,
       )--------------------------------------
x
using i

well_formed y
    assumption.
  }
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
Γ Ⱶ
take (length (l₁ ++ (nxy ∶ x and y,
                     )))
  ((l₁ ++ (nxy ∶ x and y,
           )) ++ (ny ∶ y) :: l₂) ++
(nx ∶ x)
:: drop (length (l₁ ++ (nxy ∶ x and y,
                        )))
     ((l₁ ++ (nxy ∶ x and y,
              )) ++ (ny ∶ y) :: l₂)--------------------------------------
g
using i


  eapply cast_proof_ml_hyps.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
patterns_of ?hyps =
patterns_of
  (take (length (l₁ ++ (nxy ∶ x and y,
                        )))
     ((l₁ ++ (nxy ∶ x and y,
              )) ++ (ny ∶ y) :: l₂) ++
   (nx ∶ x)
   :: drop (length (l₁ ++ (nxy ∶ x and y,
                           )))
        ((l₁ ++ (nxy ∶ x and y,
                 )) ++ (ny ∶ y) :: l₂))
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
Γ Ⱶ
?hyps--------------------------------------
g
using i

  {
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
patterns_of ?hyps =
patterns_of
  (take (length (l₁ ++ (nxy ∶ x and y,
                        )))
     ((l₁ ++ (nxy ∶ x and y,
              )) ++ (ny ∶ y) :: l₂) ++
   (nx ∶ x)
   :: drop (length (l₁ ++ (nxy ∶ x and y,
                           )))
        ((l₁ ++ (nxy ∶ x and y,
                 )) ++ (ny ∶ y) :: l₂))
    replace (l₁ ++ (mkNH _ nxy (x and y)) :: l₂) with ((l₁++ [mkNH _ nxy (x and y)]) ++ l₂).
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
patterns_of ?hyps =
patterns_of
  (take (length (l₁ ++ (nxy ∶ x and y,
                        )))
     ((l₁ ++ (nxy ∶ x and y,
              )) ++ (ny ∶ y) :: l₂) ++
   (nx ∶ x)
   :: drop (length (l₁ ++ (nxy ∶ x and y,
                           )))
        ((l₁ ++ (nxy ∶ x and y,
                 )) ++ (ny ∶ y) :: l₂))
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
(l₁ ++ (nxy ∶ x and y,
        )) ++ l₂ = l₁ ++ (nxy ∶ x and y) :: l₂
    2: {
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
(l₁ ++ (nxy ∶ x and y,
        )) ++ l₂ = l₁ ++ (nxy ∶ x and y) :: l₂ rewrite -app_assoc.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
l₁ ++ (nxy ∶ x and y,
       ) ++ l₂ = l₁ ++ (nxy ∶ x and y) :: l₂ reflexivity. }
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
patterns_of ?hyps =
patterns_of
  (take (length (l₁ ++ (nxy ∶ x and y,
                        )))
     ((l₁ ++ (nxy ∶ x and y,
              )) ++ (ny ∶ y) :: l₂) ++
   (nx ∶ x)
   :: drop (length (l₁ ++ (nxy ∶ x and y,
                           )))
        ((l₁ ++ (nxy ∶ x and y,
                 )) ++ (ny ∶ y) :: l₂))
    rewrite take_app.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
patterns_of ?hyps =
patterns_of
  ((l₁ ++ (nxy ∶ x and y,
           )) ++
   (nx ∶ x)
   :: drop (length (l₁ ++ (nxy ∶ x and y,
                           )))
        ((l₁ ++ (nxy ∶ x and y,
                 )) ++ (ny ∶ y) :: l₂)) rewrite drop_app.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
patterns_of ?hyps =
patterns_of
  ((l₁ ++ (nxy ∶ x and y,
           )) ++ (nx ∶ x) :: (ny ∶ y) :: l₂) reflexivity.
  }
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
Γ Ⱶ
(l₁ ++ (nxy ∶ x and y,
        )) ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i


  eapply cast_proof_ml_hyps.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
patterns_of ?hyps =
patterns_of
  ((l₁ ++ (nxy ∶ x and y,
           )) ++ (nx ∶ x) :: (ny ∶ y) :: l₂)
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
Γ Ⱶ
?hyps--------------------------------------
g
using i

  {
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
patterns_of ?hyps =
patterns_of
  ((l₁ ++ (nxy ∶ x and y,
           )) ++ (nx ∶ x) :: (ny ∶ y) :: l₂)
    rewrite -app_assoc.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
patterns_of ?hyps =
patterns_of
  (l₁ ++
   (nxy ∶ x and y,
    ) ++ (nx ∶ x) :: (ny ∶ y) :: l₂) reflexivity.
  }
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
Γ Ⱶ
l₁ ++ (nxy ∶ x and y,
       ) ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i


 apply mlGoal_clear_hyp.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf
  (map nh_patt l₁ ++
   map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
Γ Ⱶ
l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂--------------------------------------
g
using i

 exact H.
Defined.

Tactic Notation "mlDestructAnd" constr(name) "as" constr(name1) constr(name2) :=
  _ensureProofMode;
  _failIfUsed name1; _failIfUsed name2;
  eapply cast_proof_ml_hyps;
  f_equal;
  _mlReshapeHypsByName name;
  apply MLGoal_destructAnd with (nxy := name) (nx := name1) (ny := name2);
  _mlReshapeHypsBack.

Tactic Notation "mlDestructAnd" constr(name) :=
  _ensureProofMode;
  let hyps := _getHypNames in
  let name0 := eval cbv in (fresh hyps) in
  let name1 := eval cbv in (fresh (name0 :: hyps)) in
  mlDestructAnd name as name0 name1.

Local Example ex_mlDestructAnd {Σ : Signature} Γ a b p q:
  well_formed a ->
  well_formed b ->
  well_formed p ->
  well_formed q ->
  Γ ⊢i p and q ---> a and b ---> q ---> a
  using BasicReasoning.
Σ: Signature
Γ: Theory
a, b, p, q: Pattern
well_formed a
→ well_formed b
  → well_formed p
    → well_formed q
      → Γ ⊢i p and q ---> a and b ---> q ---> a
        using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
a, b, p, q: Pattern
well_formed a
→ well_formed b
  → well_formed p
    → well_formed q
      → Γ ⊢i p and q ---> a and b ---> q ---> a
        using BasicReasoning
  intros.
Σ: Signature
Γ: Theory
a, b, p, q: Pattern
H: well_formed a
H0: well_formed b
H1: well_formed p
H2: well_formed q
Γ ⊢i p and q ---> a and b ---> q ---> a
using BasicReasoning toMLGoal.
Σ: Signature
Γ: Theory
a, b, p, q: Pattern
H: well_formed a
H0: well_formed b
H1: well_formed p
H2: well_formed q
well_formed (p and q ---> a and b ---> q ---> a)
Σ: Signature
Γ: Theory
a, b, p, q: Pattern
H: well_formed a
H0: well_formed b
H1: well_formed p
H2: well_formed q
Γ Ⱶ
p and q ---> a and b ---> q ---> a
using BasicReasoning

  {
Σ: Signature
Γ: Theory
a, b, p, q: Pattern
H: well_formed a
H0: well_formed b
H1: well_formed p
H2: well_formed q
well_formed (p and q ---> a and b ---> q ---> a) wf_auto2. }
Σ: Signature
Γ: Theory
a, b, p, q: Pattern
H: well_formed a
H0: well_formed b
H1: well_formed p
H2: well_formed q
Γ Ⱶ
p and q ---> a and b ---> q ---> a
using BasicReasoning

  mlIntro "H0".
Σ: Signature
Γ: Theory
a, b, p, q: Pattern
H: well_formed a
H0: well_formed b
H1: well_formed p
H2: well_formed q
Γ Ⱶ
"H0" ∶ p and q,
--------------------------------------
a and b ---> q ---> a
using BasicReasoning
 mlIntro "H1".
Σ: Signature
Γ: Theory
a, b, p, q: Pattern
H: well_formed a
H0: well_formed b
H1: well_formed p
H2: well_formed q
Γ Ⱶ
"H0" ∶ p and q,
"H1" ∶ a and b,
--------------------------------------
q ---> a
using BasicReasoning
 mlIntro "H2".
Σ: Signature
Γ: Theory
a, b, p, q: Pattern
H: well_formed a
H0: well_formed b
H1: well_formed p
H2: well_formed q
Γ Ⱶ
"H0" ∶ p and q,
"H1" ∶ a and b,
"H2" ∶ q,
--------------------------------------
a
using BasicReasoning

  mlDestructAnd "H1" as "H3" "H4".
Σ: Signature
Γ: Theory
a, b, p, q: Pattern
H: well_formed a
H0: well_formed b
H1: well_formed p
H2: well_formed q
Γ Ⱶ
"H0" ∶ p and q,
"H3" ∶ a,
"H4" ∶ b,
"H2" ∶ q,
--------------------------------------
a
using BasicReasoning

  mlDestructAnd "H0".
Σ: Signature
Γ: Theory
a, b, p, q: Pattern
H: well_formed a
H0: well_formed b
H1: well_formed p
H2: well_formed q
Γ Ⱶ
"0" ∶ p,
"1" ∶ q,
"H3" ∶ a,
"H4" ∶ b,
"H2" ∶ q,
--------------------------------------
a
using BasicReasoning

  mlExact "H3".
Defined.

 
Lemma and_of_equiv_is_equiv {Σ : Signature} Γ p q p' q' i:
  well_formed p ->
  well_formed q ->
  well_formed p' ->
  well_formed q' ->
  Γ ⊢i (p <---> p') using i ->
  Γ ⊢i (q <---> q') using i ->
  Γ ⊢i ((p and q) <---> (p' and q')) using i.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
well_formed p
→ well_formed q
  → well_formed p'
    → well_formed q'
      → Γ ⊢i p <---> p' using i
        → Γ ⊢i q <---> q' using i
          → Γ ⊢i p and q <---> p' and q' using i
Proof.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
well_formed p
→ well_formed q
  → well_formed p'
    → well_formed q'
      → Γ ⊢i p <---> p' using i
        → Γ ⊢i q <---> q' using i
          → Γ ⊢i p and q <---> p' and q' using i
  intros wfp wfq wfp' wfq' pep' qeq'.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
Γ ⊢i p and q <---> p' and q' using i
  pose proof (pip' := pep').
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p <---> p' using i
Γ ⊢i p and q <---> p' and q' using i apply pf_conj_elim_l_meta in pip'; auto.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
Γ ⊢i p and q <---> p' and q' using i
  pose proof (p'ip := pep').
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p <---> p' using i
Γ ⊢i p and q <---> p' and q' using i apply pf_conj_elim_r_meta in p'ip; auto.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
Γ ⊢i p and q <---> p' and q' using i
  pose proof (qiq' := qeq').
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q <---> q' using i
Γ ⊢i p and q <---> p' and q' using i apply pf_conj_elim_l_meta in qiq'; auto.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
Γ ⊢i p and q <---> p' and q' using i
  pose proof (q'iq := qeq').
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q <---> q' using i
Γ ⊢i p and q <---> p' and q' using i apply pf_conj_elim_r_meta in q'iq; auto.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ ⊢i p and q <---> p' and q' using i

  apply conj_intro_meta; auto.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ ⊢i p and q ---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ ⊢i p' and q' ---> p and q using i
  -
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ ⊢i p and q ---> p' and q' using i toMLGoal.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
well_formed (p and q ---> p' and q')
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
p and q ---> p' and q'
using i

    {
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
well_formed (p and q ---> p' and q') wf_auto2. }
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
p and q ---> p' and q'
using i

    mlIntro "H0".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ p and q,
--------------------------------------
p' and q'
using i
 unfold patt_and.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ ! (! p or ! q),
--------------------------------------
! (! p' or ! q')
using i

    mlIntro "H1".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ ! (! p or ! q),
"H1" ∶ ! p' or ! q',
--------------------------------------
⊥
using i
 mlApply "H0".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ ! p or ! q ---> ⊥,
"H1" ∶ ! p' or ! q',
--------------------------------------
! p or ! q
using i

    mlDestructOr "H1" as "H2" "H3".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ ! p or ! q ---> ⊥,
"H2" ∶ ! p',
--------------------------------------
! p or ! q
using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ ! p or ! q ---> ⊥,
"H3" ∶ ! q',
--------------------------------------
! p or ! q
using i

    +
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ ! p or ! q ---> ⊥,
"H2" ∶ ! p',
--------------------------------------
! p or ! q
using i
 apply modus_tollens in pip'; auto 10.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i ! p' ---> ! p using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ ! p or ! q ---> ⊥,
"H2" ∶ ! p',
--------------------------------------
! p or ! q
using i

      mlAdd pip' as "H1".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i ! p' ---> ! p using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ ! p' ---> ! p,
"H0" ∶ ! p or ! q ---> ⊥,
"H2" ∶ ! p',
--------------------------------------
! p or ! q
using i

      mlLeft.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i ! p' ---> ! p using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ ! p' ---> ! p,
"H0" ∶ ! p or ! q ---> ⊥,
"H2" ∶ ! p',
--------------------------------------
! p
using i

      mlApply "H1".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i ! p' ---> ! p using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ ! p' ---> ! p,
"H0" ∶ ! p or ! q ---> ⊥,
"H2" ∶ ! p',
--------------------------------------
! p'
using i

      mlExact "H2".
    +
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ ! p or ! q ---> ⊥,
"H3" ∶ ! q',
--------------------------------------
! p or ! q
using i
 apply modus_tollens in qiq'; auto 10.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i ! q' ---> ! q using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ ! p or ! q ---> ⊥,
"H3" ∶ ! q',
--------------------------------------
! p or ! q
using i

      mlAdd qiq' as "H1".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i ! q' ---> ! q using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ ! q' ---> ! q,
"H0" ∶ ! p or ! q ---> ⊥,
"H3" ∶ ! q',
--------------------------------------
! p or ! q
using i

      mlRight.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i ! q' ---> ! q using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ ! q' ---> ! q,
"H0" ∶ ! p or ! q ---> ⊥,
"H3" ∶ ! q',
--------------------------------------
! q
using i

      mlApply "H1".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i ! q' ---> ! q using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ ! q' ---> ! q,
"H0" ∶ ! p or ! q ---> ⊥,
"H3" ∶ ! q',
--------------------------------------
! q'
using i

      mlExact "H3".
  -
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ ⊢i p' and q' ---> p and q using i toMLGoal.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
well_formed (p' and q' ---> p and q)
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
p' and q' ---> p and q
using i

    {
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
well_formed (p' and q' ---> p and q) wf_auto2. }
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
p' and q' ---> p and q
using i

    mlIntro "H0".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ p' and q',
--------------------------------------
p and q
using i
 unfold patt_and.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ ! (! p' or ! q'),
--------------------------------------
! (! p or ! q)
using i

    mlIntro "H1".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ ! (! p' or ! q'),
"H1" ∶ ! p or ! q,
--------------------------------------
⊥
using i
 mlApply "H0".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ ! p' or ! q' ---> ⊥,
"H1" ∶ ! p or ! q,
--------------------------------------
! p' or ! q'
using i

    mlDestructOr "H1" as "H2" "H3".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ ! p' or ! q' ---> ⊥,
"H2" ∶ ! p,
--------------------------------------
! p' or ! q'
using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ ! p' or ! q' ---> ⊥,
"H3" ∶ ! q,
--------------------------------------
! p' or ! q'
using i

    +
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ ! p' or ! q' ---> ⊥,
"H2" ∶ ! p,
--------------------------------------
! p' or ! q'
using i
 mlLeft.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ ! p' or ! q' ---> ⊥,
"H2" ∶ ! p,
--------------------------------------
! p'
using i

      apply modus_tollens in p'ip; auto.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i ! p ---> ! p' using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ ! p' or ! q' ---> ⊥,
"H2" ∶ ! p,
--------------------------------------
! p'
using i

      mlAdd p'ip as "H1".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i ! p ---> ! p' using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ ! p ---> ! p',
"H0" ∶ ! p' or ! q' ---> ⊥,
"H2" ∶ ! p,
--------------------------------------
! p'
using i

      mlApply "H1".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i ! p ---> ! p' using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ ! p ---> ! p',
"H0" ∶ ! p' or ! q' ---> ⊥,
"H2" ∶ ! p,
--------------------------------------
! p
using i

      mlExact "H2".
    +
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ ! p' or ! q' ---> ⊥,
"H3" ∶ ! q,
--------------------------------------
! p' or ! q'
using i
 mlRight.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ ! p' or ! q' ---> ⊥,
"H3" ∶ ! q,
--------------------------------------
! q'
using i

      apply modus_tollens in q'iq; auto.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i ! q ---> ! q' using i
Γ Ⱶ
"H0" ∶ ! p' or ! q' ---> ⊥,
"H3" ∶ ! q,
--------------------------------------
! q'
using i

      mlAdd q'iq as "H1".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i ! q ---> ! q' using i
Γ Ⱶ
"H1" ∶ ! q ---> ! q',
"H0" ∶ ! p' or ! q' ---> ⊥,
"H3" ∶ ! q,
--------------------------------------
! q'
using i

      mlApply "H1".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i ! q ---> ! q' using i
Γ Ⱶ
"H1" ∶ ! q ---> ! q',
"H0" ∶ ! p' or ! q' ---> ⊥,
"H3" ∶ ! q,
--------------------------------------
! q
using i

      mlExact "H3".
Defined. 

Lemma or_of_equiv_is_equiv {Σ : Signature} Γ p q p' q' i:
  well_formed p ->
  well_formed q ->
  well_formed p' ->
  well_formed q' ->
  Γ ⊢i (p <---> p') using i ->
  Γ ⊢i (q <---> q') using i ->
  Γ ⊢i ((p or q) <---> (p' or q')) using i.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
well_formed p
→ well_formed q
  → well_formed p'
    → well_formed q'
      → Γ ⊢i p <---> p' using i
        → Γ ⊢i q <---> q' using i
          → Γ ⊢i p or q <---> p' or q' using i
Proof with try_wfauto2.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
well_formed p
→ well_formed q
  → well_formed p'
    → well_formed q'
      → Γ ⊢i p <---> p' using i
        → Γ ⊢i q <---> q' using i
          → Γ ⊢i p or q <---> p' or q' using i
  intros wfp wfq wfp' wfq' pep' qeq'.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
Γ ⊢i p or q <---> p' or q' using i
  pose proof (pip' := pep').
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p <---> p' using i
Γ ⊢i p or q <---> p' or q' using i apply pf_conj_elim_l_meta in pip'...
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
Γ ⊢i p or q <---> p' or q' using i
  pose proof (p'ip := pep').
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p <---> p' using i
Γ ⊢i p or q <---> p' or q' using i apply pf_conj_elim_r_meta in p'ip...
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
Γ ⊢i p or q <---> p' or q' using i
  pose proof (qiq' := qeq').
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q <---> q' using i
Γ ⊢i p or q <---> p' or q' using i apply pf_conj_elim_l_meta in qiq'...
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
Γ ⊢i p or q <---> p' or q' using i
  pose proof (q'iq := qeq').
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q <---> q' using i
Γ ⊢i p or q <---> p' or q' using i apply pf_conj_elim_r_meta in q'iq...
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ ⊢i p or q <---> p' or q' using i

  apply conj_intro_meta; auto.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ ⊢i p or q ---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ ⊢i p' or q' ---> p or q using i
  -
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ ⊢i p or q ---> p' or q' using i toMLGoal.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
well_formed (p or q ---> p' or q')
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
p or q ---> p' or q'
using i

    {
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
well_formed (p or q ---> p' or q') auto. }
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
p or q ---> p' or q'
using i

    mlIntro "H0".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ p or q,
--------------------------------------
p' or q'
using i

    mlDestructOr "H0" as "H1" "H2".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ p,
--------------------------------------
p' or q'
using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H2" ∶ q,
--------------------------------------
p' or q'
using i

    +
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ p,
--------------------------------------
p' or q'
using i
 mlLeft.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ p,
--------------------------------------
p'
using i
 fromMLGoal.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ ⊢i p ---> p' using i assumption.
    +
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H2" ∶ q,
--------------------------------------
p' or q'
using i
 mlRight.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H2" ∶ q,
--------------------------------------
q'
using i
 fromMLGoal.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ ⊢i q ---> q' using i assumption.
  -
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ ⊢i p' or q' ---> p or q using i toMLGoal.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
well_formed (p' or q' ---> p or q)
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
p' or q' ---> p or q
using i

    {
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
well_formed (p' or q' ---> p or q) auto. }
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
p' or q' ---> p or q
using i

    mlIntro "H0".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ p' or q',
--------------------------------------
p or q
using i

    mlDestructOr "H0" as "H1" "H2".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ p',
--------------------------------------
p or q
using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H2" ∶ q',
--------------------------------------
p or q
using i

    +
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ p',
--------------------------------------
p or q
using i
 mlLeft.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ p',
--------------------------------------
p
using i
 fromMLGoal.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ ⊢i p' ---> p using i assumption.
    +
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H2" ∶ q',
--------------------------------------
p or q
using i
 mlRight.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H2" ∶ q',
--------------------------------------
q
using i
 fromMLGoal.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ ⊢i q' ---> q using i assumption.
Defined.


Lemma impl_iff_notp_or_q {Σ : Signature} Γ p q:
  well_formed p ->
  well_formed q ->
  Γ ⊢i ((p ---> q) <---> (! p or q))
  using BasicReasoning.
Σ: Signature
Γ: Theory
p, q: Pattern
well_formed p
→ well_formed q
  → Γ ⊢i (p ---> q) <---> ! p or q
    using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
p, q: Pattern
well_formed p
→ well_formed q
  → Γ ⊢i (p ---> q) <---> ! p or q
    using BasicReasoning
  intros wfp wfq.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ ⊢i (p ---> q) <---> ! p or q using BasicReasoning
  apply conj_intro_meta; auto.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ ⊢i (p ---> q) ---> ! p or q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ ⊢i ! p or q ---> p ---> q using BasicReasoning
  -
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ ⊢i (p ---> q) ---> ! p or q using BasicReasoning toMLGoal.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
well_formed ((p ---> q) ---> ! p or q)
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
(p ---> q) ---> ! p or q
using BasicReasoning

    {
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
well_formed ((p ---> q) ---> ! p or q) wf_auto2. }
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
(p ---> q) ---> ! p or q
using BasicReasoning

    mlIntro "H0".
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
"H0" ∶ p ---> q,
--------------------------------------
! p or q
using BasicReasoning

    mlAdd (A_or_notA Γ p wfp) as "H1".
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
"H1" ∶ p or ! p,
"H0" ∶ p ---> q,
--------------------------------------
! p or q
using BasicReasoning

    mlDestructOr "H1" as "H2" "H3".
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
"H2" ∶ p,
"H0" ∶ p ---> q,
--------------------------------------
! p or q
using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
"H3" ∶ ! p,
"H0" ∶ p ---> q,
--------------------------------------
! p or q
using BasicReasoning

    +
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
"H2" ∶ p,
"H0" ∶ p ---> q,
--------------------------------------
! p or q
using BasicReasoning
 mlRight.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
"H2" ∶ p,
"H0" ∶ p ---> q,
--------------------------------------
q
using BasicReasoning

      mlApply "H0".
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
"H2" ∶ p,
"H0" ∶ p ---> q,
--------------------------------------
p
using BasicReasoning

      mlExact "H2".
    +
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
"H3" ∶ ! p,
"H0" ∶ p ---> q,
--------------------------------------
! p or q
using BasicReasoning
 mlLeft.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
"H3" ∶ ! p,
"H0" ∶ p ---> q,
--------------------------------------
! p
using BasicReasoning

      mlExact "H3".
  -
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ ⊢i ! p or q ---> p ---> q using BasicReasoning toMLGoal.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
well_formed (! p or q ---> p ---> q)
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
! p or q ---> p ---> q
using BasicReasoning

    {
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
well_formed (! p or q ---> p ---> q) wf_auto2. }
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
! p or q ---> p ---> q
using BasicReasoning

    mlIntro "H0".
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
"H0" ∶ ! p or q,
--------------------------------------
p ---> q
using BasicReasoning
 mlIntro "H2".
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
"H0" ∶ ! p or q,
"H2" ∶ p,
--------------------------------------
q
using BasicReasoning
 unfold patt_or.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
"H0" ∶ ! ! p ---> q,
"H2" ∶ p,
--------------------------------------
q
using BasicReasoning

    mlApply "H0".
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
"H0" ∶ ! ! p ---> q,
"H2" ∶ p,
--------------------------------------
! ! p
using BasicReasoning

    mlApplyMeta not_not_intro.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
"H0" ∶ ! ! p ---> q,
"H2" ∶ p,
--------------------------------------
p
using BasicReasoning

    mlExact "H2".
Defined.

Lemma p_and_notp_is_bot {Σ : Signature} Γ p:
  well_formed p ->
  Γ ⊢i (⊥ <---> p and ! p)
  using BasicReasoning.
Σ: Signature
Γ: Theory
p: Pattern
well_formed p
→ Γ ⊢i ⊥ <---> p and ! p using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
p: Pattern
well_formed p
→ Γ ⊢i ⊥ <---> p and ! p using BasicReasoning
  intros wfp.
Σ: Signature
Γ: Theory
p: Pattern
wfp: well_formed p
Γ ⊢i ⊥ <---> p and ! p using BasicReasoning
  apply conj_intro_meta; auto.
Σ: Signature
Γ: Theory
p: Pattern
wfp: well_formed p
Γ ⊢i ⊥ ---> p and ! p using BasicReasoning
Σ: Signature
Γ: Theory
p: Pattern
wfp: well_formed p
Γ ⊢i p and ! p ---> ⊥ using BasicReasoning
  -
Σ: Signature
Γ: Theory
p: Pattern
wfp: well_formed p
Γ ⊢i ⊥ ---> p and ! p using BasicReasoning apply bot_elim; auto.
  -
Σ: Signature
Γ: Theory
p: Pattern
wfp: well_formed p
Γ ⊢i p and ! p ---> ⊥ using BasicReasoning unfold patt_and.
Σ: Signature
Γ: Theory
p: Pattern
wfp: well_formed p
Γ ⊢i ! (! p or ! ! p) ---> ⊥ using BasicReasoning
    toMLGoal.
Σ: Signature
Γ: Theory
p: Pattern
wfp: well_formed p
well_formed (! (! p or ! ! p) ---> ⊥)
Σ: Signature
Γ: Theory
p: Pattern
wfp: well_formed p
Γ Ⱶ
! (! p or ! ! p) ---> ⊥
using BasicReasoning

    {
Σ: Signature
Γ: Theory
p: Pattern
wfp: well_formed p
well_formed (! (! p or ! ! p) ---> ⊥) wf_auto2. }
Σ: Signature
Γ: Theory
p: Pattern
wfp: well_formed p
Γ Ⱶ
! (! p or ! ! p) ---> ⊥
using BasicReasoning

    mlIntro "H0".
Σ: Signature
Γ: Theory
p: Pattern
wfp: well_formed p
Γ Ⱶ
"H0" ∶ ! (! p or ! ! p),
--------------------------------------
⊥
using BasicReasoning

    mlApply "H0".
Σ: Signature
Γ: Theory
p: Pattern
wfp: well_formed p
Γ Ⱶ
"H0" ∶ ! p or ! ! p ---> ⊥,
--------------------------------------
! p or ! ! p
using BasicReasoning

    mlAdd (A_or_notA Γ (! p) ltac:(wf_auto2)) as "H1".
Σ: Signature
Γ: Theory
p: Pattern
wfp: well_formed p
Γ Ⱶ
"H1" ∶ ! p or ! ! p,
"H0" ∶ ! p or ! ! p ---> ⊥,
--------------------------------------
! p or ! ! p
using BasicReasoning

    mlExact "H1".
Defined.

Ltac mlExFalso :=
  _ensureProofMode;
  mlApplyMeta bot_elim
.

Tactic Notation "mlDestructBot" constr(name') :=
  _ensureProofMode;
  _mlReshapeHypsByName name';
  mlExFalso; mlExact name';
  _mlReshapeHypsBack.

Lemma weird_lemma  {Σ : Signature} Γ A B L R:
  well_formed A ->
  well_formed B ->
  well_formed L ->
  well_formed R ->
  Γ ⊢i (((L and A) ---> (B or R)) ---> (L ---> ((A ---> B) or R)))
  using BasicReasoning.
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
well_formed A
→ well_formed B
  → well_formed L
    → well_formed R
      → Γ
        ⊢i (L and A ---> B or R) --->
           L ---> (A ---> B) or R using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
well_formed A
→ well_formed B
  → well_formed L
    → well_formed R
      → Γ
        ⊢i (L and A ---> B or R) --->
           L ---> (A ---> B) or R using BasicReasoning
  intros wfA wfB wfL wfR.
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Γ ⊢i (L and A ---> B or R) ---> L ---> (A ---> B) or R
using BasicReasoning
  toMLGoal.
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
well_formed
  ((L and A ---> B or R) ---> L ---> (A ---> B) or R)
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Γ Ⱶ
(L and A ---> B or R) ---> L ---> (A ---> B) or R
using BasicReasoning

  {
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
well_formed
  ((L and A ---> B or R) ---> L ---> (A ---> B) or R) wf_auto2. }
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Γ Ⱶ
(L and A ---> B or R) ---> L ---> (A ---> B) or R
using BasicReasoning

  mlIntro "H0".
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Γ Ⱶ
"H0" ∶ L and A ---> B or R,
--------------------------------------
L ---> (A ---> B) or R
using BasicReasoning
 mlIntro "H1".
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Γ Ⱶ
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
--------------------------------------
(A ---> B) or R
using BasicReasoning

  mlAdd (A_or_notA Γ A wfA) as "H2".
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Γ Ⱶ
"H2" ∶ A or ! A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
--------------------------------------
(A ---> B) or R
using BasicReasoning

  mlDestructOr "H2" as "H3" "H4".
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Γ Ⱶ
"H3" ∶ A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
--------------------------------------
(A ---> B) or R
using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Γ Ⱶ
"H4" ∶ ! A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
--------------------------------------
(A ---> B) or R
using BasicReasoning

  -
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Γ Ⱶ
"H3" ∶ A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
--------------------------------------
(A ---> B) or R
using BasicReasoning
 mlAssert ("H2" : (B or R)).
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
well_formed (B or R)
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)
Γ Ⱶ
"H3" ∶ A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
--------------------------------------
B or R
using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)
Γ Ⱶ
"H3" ∶ A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
"H2" ∶ B or R,
--------------------------------------
(A ---> B) or R
using BasicReasoning

    {
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
well_formed (B or R) wf_auto2. }
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)
Γ Ⱶ
"H3" ∶ A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
--------------------------------------
B or R
using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)
Γ Ⱶ
"H3" ∶ A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
"H2" ∶ B or R,
--------------------------------------
(A ---> B) or R
using BasicReasoning

    {
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)
Γ Ⱶ
"H3" ∶ A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
--------------------------------------
B or R
using BasicReasoning
 mlApply "H0".
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)
Γ Ⱶ
"H3" ∶ A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
--------------------------------------
L and A
using BasicReasoning

      unfold patt_and at 2.
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)
Γ Ⱶ
"H3" ∶ A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
--------------------------------------
! (! L or ! A)
using BasicReasoning

      mlIntro "H2".
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)
Γ Ⱶ
"H3" ∶ A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
"H2" ∶ ! L or ! A,
--------------------------------------
⊥
using BasicReasoning

      mlDestructOr "H2" as "H4" "H5".
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)
Γ Ⱶ
"H3" ∶ A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
"H4" ∶ ! L,
--------------------------------------
⊥
using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)
Γ Ⱶ
"H3" ∶ A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
"H5" ∶ ! A,
--------------------------------------
⊥
using BasicReasoning

      +
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)
Γ Ⱶ
"H3" ∶ A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
"H4" ∶ ! L,
--------------------------------------
⊥
using BasicReasoning
 mlApply "H4".
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)
Γ Ⱶ
"H3" ∶ A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
"H4" ∶ L ---> ⊥,
--------------------------------------
L
using BasicReasoning
 mlExact "H1".
      +
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)
Γ Ⱶ
"H3" ∶ A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
"H5" ∶ ! A,
--------------------------------------
⊥
using BasicReasoning
 mlApply "H5".
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)
Γ Ⱶ
"H3" ∶ A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
"H5" ∶ A ---> ⊥,
--------------------------------------
A
using BasicReasoning
 mlExact "H3".
    }
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)
Γ Ⱶ
"H3" ∶ A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
"H2" ∶ B or R,
--------------------------------------
(A ---> B) or R
using BasicReasoning

    mlDestructOr "H2" as "H4" "H5".
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)
Γ Ⱶ
"H3" ∶ A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
"H4" ∶ B,
--------------------------------------
(A ---> B) or R
using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)
Γ Ⱶ
"H3" ∶ A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
"H5" ∶ R,
--------------------------------------
(A ---> B) or R
using BasicReasoning

    +
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)
Γ Ⱶ
"H3" ∶ A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
"H4" ∶ B,
--------------------------------------
(A ---> B) or R
using BasicReasoning
 mlLeft.
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)
Γ Ⱶ
"H3" ∶ A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
"H4" ∶ B,
--------------------------------------
A ---> B
using BasicReasoning
 mlIntro "H2".
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)
Γ Ⱶ
"H3" ∶ A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
"H4" ∶ B,
"H2" ∶ A,
--------------------------------------
B
using BasicReasoning
 mlExact "H4".
    +
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)
Γ Ⱶ
"H3" ∶ A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
"H5" ∶ R,
--------------------------------------
(A ---> B) or R
using BasicReasoning
 mlRight.
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)
Γ Ⱶ
"H3" ∶ A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
"H5" ∶ R,
--------------------------------------
R
using BasicReasoning
 mlExact "H5".
  -
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Γ Ⱶ
"H4" ∶ ! A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
--------------------------------------
(A ---> B) or R
using BasicReasoning
 mlLeft.
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Γ Ⱶ
"H4" ∶ ! A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
--------------------------------------
A ---> B
using BasicReasoning

    mlIntro "H2".
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Γ Ⱶ
"H4" ∶ ! A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
"H2" ∶ A,
--------------------------------------
B
using BasicReasoning

    mlExFalso.
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Γ Ⱶ
"H4" ∶ ! A,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
"H2" ∶ A,
--------------------------------------
⊥
using BasicReasoning

    mlApply "H4".
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Γ Ⱶ
"H4" ∶ A ---> ⊥,
"H0" ∶ L and A ---> B or R,
"H1" ∶ L,
"H2" ∶ A,
--------------------------------------
A
using BasicReasoning
 mlExact "H2".
Defined.

Lemma weird_lemma_meta {Σ : Signature} Γ A B L R i:
  well_formed A ->
  well_formed B ->
  well_formed L ->
  well_formed R ->
  Γ ⊢i ((L and A) ---> (B or R)) using i ->
  Γ ⊢i (L ---> ((A ---> B) or R)) using i.
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
i: ProofInfo
well_formed A
→ well_formed B
  → well_formed L
    → well_formed R
      → Γ ⊢i L and A ---> B or R using i
        → Γ ⊢i L ---> (A ---> B) or R using i
Proof.
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
i: ProofInfo
well_formed A
→ well_formed B
  → well_formed L
    → well_formed R
      → Γ ⊢i L and A ---> B or R using i
        → Γ ⊢i L ---> (A ---> B) or R using i
  intros WFA WFB WFL WFR H.
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFL: well_formed L
WFR: well_formed R
H: Γ ⊢i L and A ---> B or R using i
Γ ⊢i L ---> (A ---> B) or R using i
  eapply MP.
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFL: well_formed L
WFR: well_formed R
H: Γ ⊢i L and A ---> B or R using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFL: well_formed L
WFR: well_formed R
H: Γ ⊢i L and A ---> B or R using i
Γ ⊢i ?ϕ₁ ---> L ---> (A ---> B) or R using i
  2: {
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFL: well_formed L
WFR: well_formed R
H: Γ ⊢i L and A ---> B or R using i
Γ ⊢i ?ϕ₁ ---> L ---> (A ---> B) or R using i useBasicReasoning.
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFL: well_formed L
WFR: well_formed R
H: Γ ⊢i L and A ---> B or R using i
Γ ⊢i ?ϕ₁ ---> L ---> (A ---> B) or R
using BasicReasoning apply weird_lemma; assumption. }
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFL: well_formed L
WFR: well_formed R
H: Γ ⊢i L and A ---> B or R using i
Γ ⊢i L and A ---> B or R using i
  exact H.
Defined.

Lemma imp_trans_mixed_meta {Σ : Signature} Γ A B C D i :
  well_formed A -> well_formed B -> well_formed C -> well_formed D ->
  Γ ⊢i (C ---> A) using i ->
  Γ ⊢i (B ---> D) using i ->
  Γ ⊢i ((A ---> B) ---> C ---> D) using i.
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
well_formed A
→ well_formed B
  → well_formed C
    → well_formed D
      → Γ ⊢i C ---> A using i
        → Γ ⊢i B ---> D using i
          → Γ ⊢i (A ---> B) ---> C ---> D using i
Proof.
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
well_formed A
→ well_formed B
  → well_formed C
    → well_formed D
      → Γ ⊢i C ---> A using i
        → Γ ⊢i B ---> D using i
          → Γ ⊢i (A ---> B) ---> C ---> D using i
  intros WFA WFB WFC WFD H H0.
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
Γ ⊢i (A ---> B) ---> C ---> D using i
  epose proof (H1 := prf_weaken_conclusion Γ A B D WFA WFB WFD).
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (B ---> D) ---> (A ---> B) ---> A ---> D
using BasicReasoning
Γ ⊢i (A ---> B) ---> C ---> D using i
  eapply useBasicReasoning in H1.
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (B ---> D) ---> (A ---> B) ---> A ---> D
using ?i
Γ ⊢i (A ---> B) ---> C ---> D using i
  eapply MP in H1.
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (A ---> B) ---> A ---> D using ?i
Γ ⊢i (A ---> B) ---> C ---> D using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (B ---> D) ---> (A ---> B) ---> A ---> D
using ?i
Γ ⊢i B ---> D using ?i
  2: {
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (B ---> D) ---> (A ---> B) ---> A ---> D
using ?i
Γ ⊢i B ---> D using ?i exact H0. }
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (A ---> B) ---> A ---> D using i
Γ ⊢i (A ---> B) ---> C ---> D using i
  epose proof (H2 := prf_strenghten_premise Γ A C D WFA WFC WFD).
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (A ---> B) ---> A ---> D using i
H2: Γ ⊢i (C ---> A) ---> (A ---> D) ---> C ---> D
using BasicReasoning
Γ ⊢i (A ---> B) ---> C ---> D using i
  eapply useBasicReasoning in H2.
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (A ---> B) ---> A ---> D using i
H2: Γ ⊢i (C ---> A) ---> (A ---> D) ---> C ---> D
using ?i
Γ ⊢i (A ---> B) ---> C ---> D using i
  eapply MP in H2.
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (A ---> B) ---> A ---> D using i
H2: Γ ⊢i (A ---> D) ---> C ---> D using ?i
Γ ⊢i (A ---> B) ---> C ---> D using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (A ---> B) ---> A ---> D using i
H2: Γ ⊢i (C ---> A) ---> (A ---> D) ---> C ---> D
using ?i
Γ ⊢i C ---> A using ?i
  2: {
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (A ---> B) ---> A ---> D using i
H2: Γ ⊢i (C ---> A) ---> (A ---> D) ---> C ---> D
using ?i
Γ ⊢i C ---> A using ?i exact H. }
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (A ---> B) ---> A ---> D using i
H2: Γ ⊢i (A ---> D) ---> C ---> D using i
Γ ⊢i (A ---> B) ---> C ---> D using i
  epose proof (H3 := syllogism_meta _ _ _ H1 H2).
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (A ---> B) ---> A ---> D using i
H2: Γ ⊢i (A ---> D) ---> C ---> D using i
H3: Γ ⊢i (A ---> B) ---> C ---> D using i
Γ ⊢i (A ---> B) ---> C ---> D using i
  exact H3.
  Unshelve.
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (A ---> B) ---> A ---> D using i
H2: Γ ⊢i (A ---> D) ---> C ---> D using i
well_formed (A ---> B)
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (A ---> B) ---> A ---> D using i
H2: Γ ⊢i (A ---> D) ---> C ---> D using i
well_formed (A ---> D)
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (A ---> B) ---> A ---> D using i
H2: Γ ⊢i (A ---> D) ---> C ---> D using i
well_formed (C ---> D) all: wf_auto2.
Defined.

Lemma and_weaken {Σ : Signature} A B C Γ i:
  well_formed A -> well_formed B -> well_formed C ->
  Γ ⊢i (B ---> C) using i ->
  Γ ⊢i ((A and B) ---> (A and C)) using i.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
well_formed A
→ well_formed B
  → well_formed C
    → Γ ⊢i B ---> C using i
      → Γ ⊢i A and B ---> A and C using i
Proof.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
well_formed A
→ well_formed B
  → well_formed C
    → Γ ⊢i B ---> C using i
      → Γ ⊢i A and B ---> A and C using i
  intros WFA WFB WFC H.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
Γ ⊢i A and B ---> A and C using i
  epose proof (H0 := and_impl' Γ A B (A and C) _ _ _).
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ
⊢i (A ---> B ---> A and C) --->
   A and B ---> A and C using BasicReasoning
Γ ⊢i A and B ---> A and C using i
  eapply MP.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ
⊢i (A ---> B ---> A and C) --->
   A and B ---> A and C using BasicReasoning
Γ ⊢i ?ϕ₁ using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ
⊢i (A ---> B ---> A and C) --->
   A and B ---> A and C using BasicReasoning
Γ ⊢i ?ϕ₁ ---> A and B ---> A and C using i 2: {
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ
⊢i (A ---> B ---> A and C) --->
   A and B ---> A and C using BasicReasoning
Γ ⊢i ?ϕ₁ ---> A and B ---> A and C using i useBasicReasoning.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ
⊢i (A ---> B ---> A and C) --->
   A and B ---> A and C using BasicReasoning
Γ ⊢i ?ϕ₁ ---> A and B ---> A and C
using BasicReasoning exact H0. }
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ
⊢i (A ---> B ---> A and C) --->
   A and B ---> A and C using BasicReasoning
Γ ⊢i A ---> B ---> A and C using i
  apply reorder_meta.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ
⊢i (A ---> B ---> A and C) --->
   A and B ---> A and C using BasicReasoning
well_formed B
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ
⊢i (A ---> B ---> A and C) --->
   A and B ---> A and C using BasicReasoning
well_formed A
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ
⊢i (A ---> B ---> A and C) --->
   A and B ---> A and C using BasicReasoning
well_formed (A and C)
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ
⊢i (A ---> B ---> A and C) --->
   A and B ---> A and C using BasicReasoning
Γ ⊢i B ---> A ---> A and C using i
  1-3: wf_auto2.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ
⊢i (A ---> B ---> A and C) --->
   A and B ---> A and C using BasicReasoning
Γ ⊢i B ---> A ---> A and C using i
  epose proof (H1 := prf_strenghten_premise Γ C B (A ---> A and C) _ _ _).
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ
⊢i (A ---> B ---> A and C) --->
   A and B ---> A and C using BasicReasoning
H1: Γ
⊢i (B ---> C) --->
   (C ---> A ---> A and C) --->
   B ---> A ---> A and C using BasicReasoning
Γ ⊢i B ---> A ---> A and C using i
  eapply MP.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ
⊢i (A ---> B ---> A and C) --->
   A and B ---> A and C using BasicReasoning
H1: Γ
⊢i (B ---> C) --->
   (C ---> A ---> A and C) --->
   B ---> A ---> A and C using BasicReasoning
Γ ⊢i ?ϕ₁ using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ
⊢i (A ---> B ---> A and C) --->
   A and B ---> A and C using BasicReasoning
H1: Γ
⊢i (B ---> C) --->
   (C ---> A ---> A and C) --->
   B ---> A ---> A and C using BasicReasoning
Γ ⊢i ?ϕ₁ ---> B ---> A ---> A and C using i
  2: eapply MP.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ
⊢i (A ---> B ---> A and C) --->
   A and B ---> A and C using BasicReasoning
H1: Γ
⊢i (B ---> C) --->
   (C ---> A ---> A and C) --->
   B ---> A ---> A and C using BasicReasoning
Γ ⊢i ?ϕ₁ using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ
⊢i (A ---> B ---> A and C) --->
   A and B ---> A and C using BasicReasoning
H1: Γ
⊢i (B ---> C) --->
   (C ---> A ---> A and C) --->
   B ---> A ---> A and C using BasicReasoning
Γ ⊢i ?ϕ₁0 using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ
⊢i (A ---> B ---> A and C) --->
   A and B ---> A and C using BasicReasoning
H1: Γ
⊢i (B ---> C) --->
   (C ---> A ---> A and C) --->
   B ---> A ---> A and C using BasicReasoning
Γ ⊢i ?ϕ₁0 ---> ?ϕ₁ ---> B ---> A ---> A and C using i
  3: {
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ
⊢i (A ---> B ---> A and C) --->
   A and B ---> A and C using BasicReasoning
H1: Γ
⊢i (B ---> C) --->
   (C ---> A ---> A and C) --->
   B ---> A ---> A and C using BasicReasoning
Γ ⊢i ?ϕ₁0 ---> ?ϕ₁ ---> B ---> A ---> A and C using i useBasicReasoning.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ
⊢i (A ---> B ---> A and C) --->
   A and B ---> A and C using BasicReasoning
H1: Γ
⊢i (B ---> C) --->
   (C ---> A ---> A and C) --->
   B ---> A ---> A and C using BasicReasoning
Γ ⊢i ?ϕ₁0 ---> ?ϕ₁ ---> B ---> A ---> A and C
using BasicReasoning exact H1. }
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ
⊢i (A ---> B ---> A and C) --->
   A and B ---> A and C using BasicReasoning
H1: Γ
⊢i (B ---> C) --->
   (C ---> A ---> A and C) --->
   B ---> A ---> A and C using BasicReasoning
Γ ⊢i C ---> A ---> A and C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ
⊢i (A ---> B ---> A and C) --->
   A and B ---> A and C using BasicReasoning
H1: Γ
⊢i (B ---> C) --->
   (C ---> A ---> A and C) --->
   B ---> A ---> A and C using BasicReasoning
Γ ⊢i B ---> C using i
  2: {
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ
⊢i (A ---> B ---> A and C) --->
   A and B ---> A and C using BasicReasoning
H1: Γ
⊢i (B ---> C) --->
   (C ---> A ---> A and C) --->
   B ---> A ---> A and C using BasicReasoning
Γ ⊢i B ---> C using i exact H. }
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ
⊢i (A ---> B ---> A and C) --->
   A and B ---> A and C using BasicReasoning
H1: Γ
⊢i (B ---> C) --->
   (C ---> A ---> A and C) --->
   B ---> A ---> A and C using BasicReasoning
Γ ⊢i C ---> A ---> A and C using i
  useBasicReasoning.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ
⊢i (A ---> B ---> A and C) --->
   A and B ---> A and C using BasicReasoning
H1: Γ
⊢i (B ---> C) --->
   (C ---> A ---> A and C) --->
   B ---> A ---> A and C using BasicReasoning
Γ ⊢i C ---> A ---> A and C using BasicReasoning
  apply conj_intro2; assumption.
  Unshelve.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
well_formed A
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
well_formed B
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
well_formed (A and C)
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ
⊢i (A ---> B ---> A and C) --->
   A and B ---> A and C using BasicReasoning
well_formed C
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ
⊢i (A ---> B ---> A and C) --->
   A and B ---> A and C using BasicReasoning
well_formed B
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ
⊢i (A ---> B ---> A and C) --->
   A and B ---> A and C using BasicReasoning
well_formed (A ---> A and C)
  all: wf_auto2.
Defined.

Lemma impl_and {Σ : Signature} Γ A B C D i: 
  well_formed A -> well_formed B -> well_formed C -> well_formed D ->
  Γ ⊢i (A ---> B) using i ->
  Γ ⊢i (C ---> D) using i ->
  Γ ⊢i (A and C) ---> (B and D) using i.
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
well_formed A
→ well_formed B
  → well_formed C
    → well_formed D
      → Γ ⊢i A ---> B using i
        → Γ ⊢i C ---> D using i
          → Γ ⊢i A and C ---> B and D using i
Proof.
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
well_formed A
→ well_formed B
  → well_formed C
    → well_formed D
      → Γ ⊢i A ---> B using i
        → Γ ⊢i C ---> D using i
          → Γ ⊢i A and C ---> B and D using i
  intros WFA WFB WFC WFD H H0.
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i
Γ ⊢i A and C ---> B and D using i
  toMLGoal.
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i
well_formed (A and C ---> B and D)
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i
Γ Ⱶ
A and C ---> B and D
using i

  {
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i
well_formed (A and C ---> B and D) wf_auto2. }
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i
Γ Ⱶ
A and C ---> B and D
using i

  {
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i
Γ Ⱶ
A and C ---> B and D
using i

    mlAdd H as "H0".
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i
Γ Ⱶ
"H0" ∶ A ---> B,
--------------------------------------
A and C ---> B and D
using i

    mlAdd H0 as "H1".
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i
Γ Ⱶ
"H1" ∶ C ---> D,
"H0" ∶ A ---> B,
--------------------------------------
A and C ---> B and D
using i

    mlIntro "H2".
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i
Γ Ⱶ
"H1" ∶ C ---> D,
"H0" ∶ A ---> B,
"H2" ∶ A and C,
--------------------------------------
B and D
using i

    mlDestructAnd "H2" as "H3" "H4".
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i
Γ Ⱶ
"H1" ∶ C ---> D,
"H0" ∶ A ---> B,
"H3" ∶ A,
"H4" ∶ C,
--------------------------------------
B and D
using i

    mlIntro "H5".
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i
Γ Ⱶ
"H1" ∶ C ---> D,
"H0" ∶ A ---> B,
"H3" ∶ A,
"H4" ∶ C,
"H5" ∶ ! B or ! D,
--------------------------------------
⊥
using i

    mlDestructOr "H5" as "H6" "H7".
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i
Γ Ⱶ
"H1" ∶ C ---> D,
"H0" ∶ A ---> B,
"H3" ∶ A,
"H4" ∶ C,
"H6" ∶ ! B,
--------------------------------------
⊥
using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i
Γ Ⱶ
"H1" ∶ C ---> D,
"H0" ∶ A ---> B,
"H3" ∶ A,
"H4" ∶ C,
"H7" ∶ ! D,
--------------------------------------
⊥
using i

    {
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i
Γ Ⱶ
"H1" ∶ C ---> D,
"H0" ∶ A ---> B,
"H3" ∶ A,
"H4" ∶ C,
"H6" ∶ ! B,
--------------------------------------
⊥
using i

      mlApply "H6".
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i
Γ Ⱶ
"H1" ∶ C ---> D,
"H0" ∶ A ---> B,
"H3" ∶ A,
"H4" ∶ C,
"H6" ∶ B ---> ⊥,
--------------------------------------
B
using i

      mlApply "H0".
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i
Γ Ⱶ
"H1" ∶ C ---> D,
"H0" ∶ A ---> B,
"H3" ∶ A,
"H4" ∶ C,
"H6" ∶ B ---> ⊥,
--------------------------------------
A
using i

      mlExact "H3".
    }
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i
Γ Ⱶ
"H1" ∶ C ---> D,
"H0" ∶ A ---> B,
"H3" ∶ A,
"H4" ∶ C,
"H7" ∶ ! D,
--------------------------------------
⊥
using i

    {
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i
Γ Ⱶ
"H1" ∶ C ---> D,
"H0" ∶ A ---> B,
"H3" ∶ A,
"H4" ∶ C,
"H7" ∶ ! D,
--------------------------------------
⊥
using i

      mlApply "H7".
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i
Γ Ⱶ
"H1" ∶ C ---> D,
"H0" ∶ A ---> B,
"H3" ∶ A,
"H4" ∶ C,
"H7" ∶ D ---> ⊥,
--------------------------------------
D
using i

      mlApply "H1".
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i
Γ Ⱶ
"H1" ∶ C ---> D,
"H0" ∶ A ---> B,
"H3" ∶ A,
"H4" ∶ C,
"H7" ∶ D ---> ⊥,
--------------------------------------
C
using i

      mlExact "H4".
    }
  }
Defined.

Lemma and_drop {Σ : Signature} A B C Γ i:
  well_formed A -> well_formed B -> well_formed C ->
  Γ ⊢i ((A and B) ---> C) using i ->
  Γ ⊢i ((A and B) ---> (A and C)) using i.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
well_formed A
→ well_formed B
  → well_formed C
    → Γ ⊢i A and B ---> C using i
      → Γ ⊢i A and B ---> A and C using i
Proof.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
well_formed A
→ well_formed B
  → well_formed C
    → Γ ⊢i A and B ---> C using i
      → Γ ⊢i A and B ---> A and C using i
  intros WFA WFB WFC H.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i
Γ ⊢i A and B ---> A and C using i
  toMLGoal.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i
well_formed (A and B ---> A and C)
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i
Γ Ⱶ
A and B ---> A and C
using i

  {
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i
well_formed (A and B ---> A and C) wf_auto2. }
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i
Γ Ⱶ
A and B ---> A and C
using i

  mlAdd H as "H0".
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i
Γ Ⱶ
"H0" ∶ A and B ---> C,
--------------------------------------
A and B ---> A and C
using i

  mlIntro "H1".
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i
Γ Ⱶ
"H0" ∶ A and B ---> C,
"H1" ∶ A and B,
--------------------------------------
A and C
using i

  mlIntro "H2".
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i
Γ Ⱶ
"H0" ∶ A and B ---> C,
"H1" ∶ A and B,
"H2" ∶ ! A or ! C,
--------------------------------------
⊥
using i

  mlDestructOr "H2" as "H3" "H4".
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i
Γ Ⱶ
"H0" ∶ A and B ---> C,
"H1" ∶ A and B,
"H3" ∶ ! A,
--------------------------------------
⊥
using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i
Γ Ⱶ
"H0" ∶ A and B ---> C,
"H1" ∶ A and B,
"H4" ∶ ! C,
--------------------------------------
⊥
using i

  {
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i
Γ Ⱶ
"H0" ∶ A and B ---> C,
"H1" ∶ A and B,
"H3" ∶ ! A,
--------------------------------------
⊥
using i

    mlDestructAnd "H1" as "H5" "H6".
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i
Γ Ⱶ
"H0" ∶ A and B ---> C,
"H5" ∶ A,
"H6" ∶ B,
"H3" ∶ ! A,
--------------------------------------
⊥
using i

    mlApply "H3".
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i
Γ Ⱶ
"H0" ∶ A and B ---> C,
"H5" ∶ A,
"H6" ∶ B,
"H3" ∶ A ---> ⊥,
--------------------------------------
A
using i

    mlExact "H5".
  }
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i
Γ Ⱶ
"H0" ∶ A and B ---> C,
"H1" ∶ A and B,
"H4" ∶ ! C,
--------------------------------------
⊥
using i

  {
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i
Γ Ⱶ
"H0" ∶ A and B ---> C,
"H1" ∶ A and B,
"H4" ∶ ! C,
--------------------------------------
⊥
using i

    mlApply "H4".
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i
Γ Ⱶ
"H0" ∶ A and B ---> C,
"H1" ∶ A and B,
"H4" ∶ C ---> ⊥,
--------------------------------------
C
using i

    mlApply "H0".
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i
Γ Ⱶ
"H0" ∶ A and B ---> C,
"H1" ∶ A and B,
"H4" ∶ C ---> ⊥,
--------------------------------------
A and B
using i

    mlExact "H1".
  }
Defined.


Lemma prf_equiv_of_impl_of_equiv {Σ : Signature} Γ a b a' b' i:
  well_formed a = true ->
  well_formed b = true ->
  well_formed a' = true ->
  well_formed b' = true ->
  Γ ⊢i (a <---> a') using i ->
  Γ ⊢i (b <---> b') using i ->
  Γ ⊢i (a ---> b) <---> (a' ---> b') using i.
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
well_formed a = true
→ well_formed b = true
  → well_formed a' = true
    → well_formed b' = true
      → Γ ⊢i a <---> a' using i
        → Γ ⊢i b <---> b' using i
          → Γ ⊢i (a ---> b) <---> (a' ---> b') using i
Proof.
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
well_formed a = true
→ well_formed b = true
  → well_formed a' = true
    → well_formed b' = true
      → Γ ⊢i a <---> a' using i
        → Γ ⊢i b <---> b' using i
          → Γ ⊢i (a ---> b) <---> (a' ---> b') using i
  intros wfa wfb wfa' wfb' Haa' Hbb'.
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Γ ⊢i (a ---> b) <---> (a' ---> b') using i
  unshelve(epose proof (Haa'1 := pf_conj_elim_l_meta _ _ _ _ _ _ Haa')).
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
well_formed (a ---> a')
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
well_formed (a' ---> a)
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Γ ⊢i (a ---> b) <---> (a' ---> b') using i
  {
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
well_formed (a ---> a') wf_auto2. }
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
well_formed (a' ---> a)
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Γ ⊢i (a ---> b) <---> (a' ---> b') using i
  {
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
well_formed (a' ---> a) wf_auto2. }
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Γ ⊢i (a ---> b) <---> (a' ---> b') using i
  unshelve(epose proof (Haa'2 := pf_conj_elim_r_meta _ _ _ _ _ _ Haa')).
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
well_formed (a ---> a')
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
well_formed (a' ---> a)
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Γ ⊢i (a ---> b) <---> (a' ---> b') using i
  {
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
well_formed (a ---> a') wf_auto2. }
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
well_formed (a' ---> a)
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Γ ⊢i (a ---> b) <---> (a' ---> b') using i
  {
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
well_formed (a' ---> a) wf_auto2. }
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Γ ⊢i (a ---> b) <---> (a' ---> b') using i
  unshelve(epose proof (Hbb'1 := pf_conj_elim_l_meta _ _ _ _ _ _ Hbb')).
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
well_formed (b ---> b')
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
well_formed (b' ---> b)
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Γ ⊢i (a ---> b) <---> (a' ---> b') using i
  {
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
well_formed (b ---> b') wf_auto2. }
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
well_formed (b' ---> b)
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Γ ⊢i (a ---> b) <---> (a' ---> b') using i
  {
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
well_formed (b' ---> b) wf_auto2. }
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Γ ⊢i (a ---> b) <---> (a' ---> b') using i
  unshelve(epose proof (Hbb'2 := pf_conj_elim_r_meta _ _ _ _ _ _ Hbb')).
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
well_formed (b ---> b')
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
well_formed (b' ---> b)
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a ---> b) <---> (a' ---> b') using i
  {
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
well_formed (b ---> b') wf_auto2. }
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
well_formed (b' ---> b)
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a ---> b) <---> (a' ---> b') using i
  {
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
well_formed (b' ---> b) wf_auto2. }
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a ---> b) <---> (a' ---> b') using i

  apply pf_iff_equiv_trans with (B := (a ---> b')).
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
well_formed (a ---> b)
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
well_formed (a ---> b')
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
well_formed (a' ---> b')
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a ---> b) <---> (a ---> b') using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a ---> b') <---> (a' ---> b') using i
  1-3: wf_auto2.
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a ---> b) <---> (a ---> b') using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a ---> b') <---> (a' ---> b') using i
    +
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a ---> b) <---> (a ---> b') using i apply conj_intro_meta.
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
well_formed ((a ---> b) ---> a ---> b')
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
well_formed ((a ---> b') ---> a ---> b)
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a ---> b) ---> a ---> b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a ---> b') ---> a ---> b using i
      1-2: wf_auto2.
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a ---> b) ---> a ---> b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a ---> b') ---> a ---> b using i
      *
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a ---> b) ---> a ---> b' using i toMLGoal.
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
well_formed ((a ---> b) ---> a ---> b')
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
(a ---> b) ---> a ---> b'
using i

        {
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
well_formed ((a ---> b) ---> a ---> b') wf_auto2. }
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
(a ---> b) ---> a ---> b'
using i

        mlIntro "H0".
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
"H0" ∶ a ---> b,
--------------------------------------
a ---> b'
using i
 mlIntro "H1".
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
"H0" ∶ a ---> b,
"H1" ∶ a,
--------------------------------------
b'
using i

        mlAdd Hbb'1 as "H2".
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
"H2" ∶ b ---> b',
"H0" ∶ a ---> b,
"H1" ∶ a,
--------------------------------------
b'
using i

        mlApply "H2".
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
"H2" ∶ b ---> b',
"H0" ∶ a ---> b,
"H1" ∶ a,
--------------------------------------
b
using i

        mlApply "H0".
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
"H2" ∶ b ---> b',
"H0" ∶ a ---> b,
"H1" ∶ a,
--------------------------------------
a
using i

        mlExact "H1".
      *
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a ---> b') ---> a ---> b using i toMLGoal.
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
well_formed ((a ---> b') ---> a ---> b)
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
(a ---> b') ---> a ---> b
using i

        {
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
well_formed ((a ---> b') ---> a ---> b) wf_auto2. }
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
(a ---> b') ---> a ---> b
using i

        mlIntro "H0".
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
"H0" ∶ a ---> b',
--------------------------------------
a ---> b
using i
 mlIntro "H1".
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
"H0" ∶ a ---> b',
"H1" ∶ a,
--------------------------------------
b
using i

        mlAdd Hbb'2 as "H2".
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
"H2" ∶ b' ---> b,
"H0" ∶ a ---> b',
"H1" ∶ a,
--------------------------------------
b
using i

        mlApply "H2".
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
"H2" ∶ b' ---> b,
"H0" ∶ a ---> b',
"H1" ∶ a,
--------------------------------------
b'
using i

        mlApply "H0".
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
"H2" ∶ b' ---> b,
"H0" ∶ a ---> b',
"H1" ∶ a,
--------------------------------------
a
using i

        mlExact "H1".
    +
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a ---> b') <---> (a' ---> b') using i apply conj_intro_meta.
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
well_formed ((a ---> b') ---> a' ---> b')
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
well_formed ((a' ---> b') ---> a ---> b')
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a ---> b') ---> a' ---> b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a' ---> b') ---> a ---> b' using i
      1-2: wf_auto2.
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a ---> b') ---> a' ---> b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a' ---> b') ---> a ---> b' using i
      *
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a ---> b') ---> a' ---> b' using i toMLGoal.
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
well_formed ((a ---> b') ---> a' ---> b')
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
(a ---> b') ---> a' ---> b'
using i

        {
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
well_formed ((a ---> b') ---> a' ---> b') wf_auto2. }
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
(a ---> b') ---> a' ---> b'
using i

        mlIntro "H0".
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
"H0" ∶ a ---> b',
--------------------------------------
a' ---> b'
using i
 mlIntro "H1".
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
"H0" ∶ a ---> b',
"H1" ∶ a',
--------------------------------------
b'
using i

        mlAdd Haa'2 as "H2".
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
"H2" ∶ a' ---> a,
"H0" ∶ a ---> b',
"H1" ∶ a',
--------------------------------------
b'
using i

        mlApply "H0".
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
"H2" ∶ a' ---> a,
"H0" ∶ a ---> b',
"H1" ∶ a',
--------------------------------------
a
using i

        mlApply "H2".
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
"H2" ∶ a' ---> a,
"H0" ∶ a ---> b',
"H1" ∶ a',
--------------------------------------
a'
using i

        mlExact "H1".
      *
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a' ---> b') ---> a ---> b' using i toMLGoal.
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
well_formed ((a' ---> b') ---> a ---> b')
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
(a' ---> b') ---> a ---> b'
using i

        {
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
well_formed ((a' ---> b') ---> a ---> b') wf_auto2. }
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
(a' ---> b') ---> a ---> b'
using i

        mlIntro "H0".
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
"H0" ∶ a' ---> b',
--------------------------------------
a ---> b'
using i
 mlIntro "H1".
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
"H0" ∶ a' ---> b',
"H1" ∶ a,
--------------------------------------
b'
using i

        mlAdd Haa'1 as "H2".
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
"H2" ∶ a ---> a',
"H0" ∶ a' ---> b',
"H1" ∶ a,
--------------------------------------
b'
using i

        mlApply "H0".
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
"H2" ∶ a ---> a',
"H0" ∶ a' ---> b',
"H1" ∶ a,
--------------------------------------
a'
using i

        mlApply "H2".
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ
"H2" ∶ a ---> a',
"H0" ∶ a' ---> b',
"H1" ∶ a,
--------------------------------------
a
using i

        mlExact "H1".
Defined.



Lemma lhs_to_and {Σ : Signature} Γ a b c i:
  well_formed a ->
  well_formed b ->
  well_formed c ->
  Γ ⊢i (a and b) ---> c using i ->
  Γ ⊢i a ---> b ---> c using i.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
well_formed a
→ well_formed b
  → well_formed c
    → Γ ⊢i a and b ---> c using i
      → Γ ⊢i a ---> b ---> c using i
Proof.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
well_formed a
→ well_formed b
  → well_formed c
    → Γ ⊢i a and b ---> c using i
      → Γ ⊢i a ---> b ---> c using i
  intros wfa wfb wfc H.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i
Γ ⊢i a ---> b ---> c using i
  toMLGoal.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i
well_formed (a ---> b ---> c)
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i
Γ Ⱶ
a ---> b ---> c
using i

  {
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i
well_formed (a ---> b ---> c) wf_auto2. }
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i
Γ Ⱶ
a ---> b ---> c
using i

  mlIntro "H0".
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i
Γ Ⱶ
"H0" ∶ a,
--------------------------------------
b ---> c
using i
 mlIntro "H1".
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ b,
--------------------------------------
c
using i

  mlApplyMeta H.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ b,
--------------------------------------
a and b
using i

  fromMLGoal.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i
Γ ⊢i a ---> b ---> a and b using i
  useBasicReasoning.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i
Γ ⊢i a ---> b ---> a and b using BasicReasoning
  apply conj_intro.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i
well_formed a
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i
well_formed b
  {
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i
well_formed a wf_auto2. }
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i
well_formed b
  {
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i
well_formed b wf_auto2. }
Defined.

Lemma lhs_from_and {Σ : Signature} Γ a b c i:
  well_formed a ->
  well_formed b ->
  well_formed c ->
  Γ ⊢i a ---> b ---> c using i ->
  Γ ⊢i (a and b) ---> c using i.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
well_formed a
→ well_formed b
  → well_formed c
    → Γ ⊢i a ---> b ---> c using i
      → Γ ⊢i a and b ---> c using i
Proof.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
well_formed a
→ well_formed b
  → well_formed c
    → Γ ⊢i a ---> b ---> c using i
      → Γ ⊢i a and b ---> c using i
  intros wfa wfb wfc H.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Γ ⊢i a and b ---> c using i
  toMLGoal.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
well_formed (a and b ---> c)
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Γ Ⱶ
a and b ---> c
using i

  {
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
well_formed (a and b ---> c) wf_auto2. }
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Γ Ⱶ
a and b ---> c
using i

  mlIntro "H0".
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Γ Ⱶ
"H0" ∶ a and b,
--------------------------------------
c
using i

  mlAssert ("H1" : b).
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
well_formed b
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Γ Ⱶ
"H0" ∶ a and b,
--------------------------------------
b
using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Γ Ⱶ
"H0" ∶ a and b,
"H1" ∶ b,
--------------------------------------
c
using i

  {
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
well_formed b wf_auto2. }
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Γ Ⱶ
"H0" ∶ a and b,
--------------------------------------
b
using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Γ Ⱶ
"H0" ∶ a and b,
"H1" ∶ b,
--------------------------------------
c
using i

  {
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Γ Ⱶ
"H0" ∶ a and b,
--------------------------------------
b
using i
 fromMLGoal.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Γ ⊢i a and b ---> b using i useBasicReasoning.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Γ ⊢i a and b ---> b using BasicReasoning apply pf_conj_elim_r.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
well_formed a
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
well_formed b
    wf_auto2.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
well_formed b wf_auto2.
  }
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Γ Ⱶ
"H0" ∶ a and b,
"H1" ∶ b,
--------------------------------------
c
using i

  mlAssert ("H2" : a) using first 1.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
l1: list named_hypothesis
Heql1: l1 = ("H0" ∶ a and b,
      )
l2: list named_hypothesis
Heql2: l2 = ("H1" ∶ b,
      )
well_formed a
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Γ Ⱶ
"H0" ∶ a and b,
--------------------------------------
a
using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Γ Ⱶ
"H0" ∶ a and b,
"H2" ∶ a,
"H1" ∶ b,
--------------------------------------
c
using i

  {
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
l1: list named_hypothesis
Heql1: l1 = ("H0" ∶ a and b,
      )
l2: list named_hypothesis
Heql2: l2 = ("H1" ∶ b,
      )
well_formed a wf_auto2. }
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Γ Ⱶ
"H0" ∶ a and b,
--------------------------------------
a
using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Γ Ⱶ
"H0" ∶ a and b,
"H2" ∶ a,
"H1" ∶ b,
--------------------------------------
c
using i

  {
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Γ Ⱶ
"H0" ∶ a and b,
--------------------------------------
a
using i
 fromMLGoal.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Γ ⊢i a and b ---> a using i useBasicReasoning.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Γ ⊢i a and b ---> a using BasicReasoning apply pf_conj_elim_l; wf_auto2. }
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Γ Ⱶ
"H0" ∶ a and b,
"H2" ∶ a,
"H1" ∶ b,
--------------------------------------
c
using i

  mlAdd H as "H3".
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Γ Ⱶ
"H3" ∶ a ---> b ---> c,
"H0" ∶ a and b,
"H2" ∶ a,
"H1" ∶ b,
--------------------------------------
c
using i

  mlAssert ("H4" : (b ---> c)).
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
well_formed (b ---> c)
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Hwf1: well_formed (b ---> c)
Γ Ⱶ
"H3" ∶ a ---> b ---> c,
"H0" ∶ a and b,
"H2" ∶ a,
"H1" ∶ b,
--------------------------------------
b ---> c
using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Hwf1: well_formed (b ---> c)
Γ Ⱶ
"H3" ∶ a ---> b ---> c,
"H0" ∶ a and b,
"H2" ∶ a,
"H1" ∶ b,
"H4" ∶ b ---> c,
--------------------------------------
c
using i

  {
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
well_formed (b ---> c) wf_auto2. }
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Hwf1: well_formed (b ---> c)
Γ Ⱶ
"H3" ∶ a ---> b ---> c,
"H0" ∶ a and b,
"H2" ∶ a,
"H1" ∶ b,
--------------------------------------
b ---> c
using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Hwf1: well_formed (b ---> c)
Γ Ⱶ
"H3" ∶ a ---> b ---> c,
"H0" ∶ a and b,
"H2" ∶ a,
"H1" ∶ b,
"H4" ∶ b ---> c,
--------------------------------------
c
using i

  {
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Hwf1: well_formed (b ---> c)
Γ Ⱶ
"H3" ∶ a ---> b ---> c,
"H0" ∶ a and b,
"H2" ∶ a,
"H1" ∶ b,
--------------------------------------
b ---> c
using i
 mlApply "H3".
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Hwf1: well_formed (b ---> c)
Γ Ⱶ
"H3" ∶ a ---> b ---> c,
"H0" ∶ a and b,
"H2" ∶ a,
"H1" ∶ b,
--------------------------------------
a
using i
 mlExact "H2". }
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Hwf1: well_formed (b ---> c)
Γ Ⱶ
"H3" ∶ a ---> b ---> c,
"H0" ∶ a and b,
"H2" ∶ a,
"H1" ∶ b,
"H4" ∶ b ---> c,
--------------------------------------
c
using i

  mlApply "H4".
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Hwf1: well_formed (b ---> c)
Γ Ⱶ
"H3" ∶ a ---> b ---> c,
"H0" ∶ a and b,
"H2" ∶ a,
"H1" ∶ b,
"H4" ∶ b ---> c,
--------------------------------------
b
using i

  mlExact "H1".
Defined.

Lemma prf_conj_split {Σ : Signature} Γ a b l:
  well_formed a ->
  well_formed b ->
  Pattern.wf l ->
  Γ ⊢i (foldr patt_imp a l) ---> (foldr patt_imp b l) ---> (foldr patt_imp (a and b) l)
  using BasicReasoning.
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
well_formed a
→ well_formed b
  → Pattern.wf l
    → Γ
      ⊢i foldr patt_imp a l --->
         foldr patt_imp b l --->
         foldr patt_imp (a and b) l
      using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
well_formed a
→ well_formed b
  → Pattern.wf l
    → Γ
      ⊢i foldr patt_imp a l --->
         foldr patt_imp b l --->
         foldr patt_imp (a and b) l
      using BasicReasoning
  intros wfa wfb wfl.
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf l
Γ
⊢i foldr patt_imp a l --->
   foldr patt_imp b l ---> foldr patt_imp (a and b) l
using BasicReasoning
  induction l.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf []
Γ
⊢i foldr patt_imp a [] --->
   foldr patt_imp b [] --->
   foldr patt_imp (a and b) [] using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Pattern.wf l
→ Γ
⊢i foldr patt_imp a l --->
foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
Γ
⊢i foldr patt_imp a (a0 :: l) --->
   foldr patt_imp b (a0 :: l) --->
   foldr patt_imp (a and b) (a0 :: l)
using BasicReasoning
  -
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf []
Γ
⊢i foldr patt_imp a [] --->
   foldr patt_imp b [] --->
   foldr patt_imp (a and b) [] using BasicReasoning simpl.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf []
Γ ⊢i a ---> b ---> a and b using BasicReasoning apply conj_intro; assumption.
  -
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Pattern.wf l
→ Γ
⊢i foldr patt_imp a l --->
foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
Γ
⊢i foldr patt_imp a (a0 :: l) --->
   foldr patt_imp b (a0 :: l) --->
   foldr patt_imp (a and b) (a0 :: l)
using BasicReasoning simpl.
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Pattern.wf l
→ Γ
⊢i foldr patt_imp a l --->
foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
Γ
⊢i (a0 ---> foldr patt_imp a l) --->
   (a0 ---> foldr patt_imp b l) --->
   a0 ---> foldr patt_imp (a and b) l
using BasicReasoning pose proof (wfl' := wfl).
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Pattern.wf l
→ Γ
⊢i foldr patt_imp a l --->
foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfl': Pattern.wf (a0 :: l)
Γ
⊢i (a0 ---> foldr patt_imp a l) --->
   (a0 ---> foldr patt_imp b l) --->
   a0 ---> foldr patt_imp (a and b) l
using BasicReasoning unfold Pattern.wf in wfl'.
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Pattern.wf l
→ Γ
⊢i foldr patt_imp a l --->
foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfl': foldr andb true (map well_formed (a0 :: l))
Γ
⊢i (a0 ---> foldr patt_imp a l) --->
   (a0 ---> foldr patt_imp b l) --->
   a0 ---> foldr patt_imp (a and b) l
using BasicReasoning simpl in wfl'.
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Pattern.wf l
→ Γ
⊢i foldr patt_imp a l --->
foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfl': well_formed a0 &&
foldr andb true (map well_formed l)
Γ
⊢i (a0 ---> foldr patt_imp a l) --->
   (a0 ---> foldr patt_imp b l) --->
   a0 ---> foldr patt_imp (a and b) l
using BasicReasoning apply andb_prop in wfl' as [wfa0 wfl'].
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Pattern.wf l
→ Γ
⊢i foldr patt_imp a l --->
foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Γ
⊢i (a0 ---> foldr patt_imp a l) --->
   (a0 ---> foldr patt_imp b l) --->
   a0 ---> foldr patt_imp (a and b) l
using BasicReasoning
    specialize (IHl wfl').
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Γ
⊢i (a0 ---> foldr patt_imp a l) --->
   (a0 ---> foldr patt_imp b l) --->
   a0 ---> foldr patt_imp (a and b) l
using BasicReasoning
    toMLGoal.
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
well_formed
  ((a0 ---> foldr patt_imp a l) --->
   (a0 ---> foldr patt_imp b l) --->
   a0 ---> foldr patt_imp (a and b) l)
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l --->
   foldr patt_imp b l --->
   foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
(a0 ---> foldr patt_imp a l) --->
(a0 ---> foldr patt_imp b l) --->
a0 ---> foldr patt_imp (a and b) l
using BasicReasoning

    {
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
well_formed
  ((a0 ---> foldr patt_imp a l) --->
   (a0 ---> foldr patt_imp b l) --->
   a0 ---> foldr patt_imp (a and b) l) wf_auto2. }
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
(a0 ---> foldr patt_imp a l) --->
(a0 ---> foldr patt_imp b l) --->
a0 ---> foldr patt_imp (a and b) l
using BasicReasoning

    mlIntro "H0".
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
"H0" ∶ a0 ---> foldr patt_imp a l,
--------------------------------------
(a0 ---> foldr patt_imp b l) --->
a0 ---> foldr patt_imp (a and b) l
using BasicReasoning
 mlIntro "H1".
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
"H0" ∶ a0 ---> foldr patt_imp a l,
"H1" ∶ a0 ---> foldr patt_imp b l,
--------------------------------------
a0 ---> foldr patt_imp (a and b) l
using BasicReasoning
 mlIntro "H2".
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
"H0" ∶ a0 ---> foldr patt_imp a l,
"H1" ∶ a0 ---> foldr patt_imp b l,
"H2" ∶ a0,
--------------------------------------
foldr patt_imp (a and b) l
using BasicReasoning

    mlAssert ("H3" : (foldr patt_imp a l)).
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
well_formed (foldr patt_imp a l)
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l --->
   foldr patt_imp b l --->
   foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Γ Ⱶ
"H0" ∶ a0 ---> foldr patt_imp a l,
"H1" ∶ a0 ---> foldr patt_imp b l,
"H2" ∶ a0,
--------------------------------------
foldr patt_imp a l
using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l --->
   foldr patt_imp b l --->
   foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Γ Ⱶ
"H0" ∶ a0 ---> foldr patt_imp a l,
"H1" ∶ a0 ---> foldr patt_imp b l,
"H2" ∶ a0,
"H3" ∶ foldr patt_imp a l,
--------------------------------------
foldr patt_imp (a and b) l
using BasicReasoning

    {
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
well_formed (foldr patt_imp a l) wf_auto2. }
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Γ Ⱶ
"H0" ∶ a0 ---> foldr patt_imp a l,
"H1" ∶ a0 ---> foldr patt_imp b l,
"H2" ∶ a0,
--------------------------------------
foldr patt_imp a l
using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l --->
   foldr patt_imp b l --->
   foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Γ Ⱶ
"H0" ∶ a0 ---> foldr patt_imp a l,
"H1" ∶ a0 ---> foldr patt_imp b l,
"H2" ∶ a0,
"H3" ∶ foldr patt_imp a l,
--------------------------------------
foldr patt_imp (a and b) l
using BasicReasoning

    {
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Γ Ⱶ
"H0" ∶ a0 ---> foldr patt_imp a l,
"H1" ∶ a0 ---> foldr patt_imp b l,
"H2" ∶ a0,
--------------------------------------
foldr patt_imp a l
using BasicReasoning
 mlApply "H0".
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Γ Ⱶ
"H0" ∶ a0 ---> foldr patt_imp a l,
"H1" ∶ a0 ---> foldr patt_imp b l,
"H2" ∶ a0,
--------------------------------------
a0
using BasicReasoning
 mlExact "H2". }
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Γ Ⱶ
"H0" ∶ a0 ---> foldr patt_imp a l,
"H1" ∶ a0 ---> foldr patt_imp b l,
"H2" ∶ a0,
"H3" ∶ foldr patt_imp a l,
--------------------------------------
foldr patt_imp (a and b) l
using BasicReasoning

    mlAssert ("H4" : (foldr patt_imp b l)).
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
well_formed (foldr patt_imp b l)
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l --->
   foldr patt_imp b l --->
   foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Hwf0: well_formed (foldr patt_imp b l)
Γ Ⱶ
"H0" ∶ a0 ---> foldr patt_imp a l,
"H1" ∶ a0 ---> foldr patt_imp b l,
"H2" ∶ a0,
"H3" ∶ foldr patt_imp a l,
--------------------------------------
foldr patt_imp b l
using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l --->
   foldr patt_imp b l --->
   foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Hwf0: well_formed (foldr patt_imp b l)
Γ Ⱶ
"H0" ∶ a0 ---> foldr patt_imp a l,
"H1" ∶ a0 ---> foldr patt_imp b l,
"H2" ∶ a0,
"H3" ∶ foldr patt_imp a l,
"H4" ∶ foldr patt_imp b l,
--------------------------------------
foldr patt_imp (a and b) l
using BasicReasoning

    {
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
well_formed (foldr patt_imp b l) wf_auto2. }
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Hwf0: well_formed (foldr patt_imp b l)
Γ Ⱶ
"H0" ∶ a0 ---> foldr patt_imp a l,
"H1" ∶ a0 ---> foldr patt_imp b l,
"H2" ∶ a0,
"H3" ∶ foldr patt_imp a l,
--------------------------------------
foldr patt_imp b l
using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l --->
   foldr patt_imp b l --->
   foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Hwf0: well_formed (foldr patt_imp b l)
Γ Ⱶ
"H0" ∶ a0 ---> foldr patt_imp a l,
"H1" ∶ a0 ---> foldr patt_imp b l,
"H2" ∶ a0,
"H3" ∶ foldr patt_imp a l,
"H4" ∶ foldr patt_imp b l,
--------------------------------------
foldr patt_imp (a and b) l
using BasicReasoning

    {
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Hwf0: well_formed (foldr patt_imp b l)
Γ Ⱶ
"H0" ∶ a0 ---> foldr patt_imp a l,
"H1" ∶ a0 ---> foldr patt_imp b l,
"H2" ∶ a0,
"H3" ∶ foldr patt_imp a l,
--------------------------------------
foldr patt_imp b l
using BasicReasoning
 mlApply "H1".
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Hwf0: well_formed (foldr patt_imp b l)
Γ Ⱶ
"H0" ∶ a0 ---> foldr patt_imp a l,
"H1" ∶ a0 ---> foldr patt_imp b l,
"H2" ∶ a0,
"H3" ∶ foldr patt_imp a l,
--------------------------------------
a0
using BasicReasoning
 mlExact "H2". }
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Hwf0: well_formed (foldr patt_imp b l)
Γ Ⱶ
"H0" ∶ a0 ---> foldr patt_imp a l,
"H1" ∶ a0 ---> foldr patt_imp b l,
"H2" ∶ a0,
"H3" ∶ foldr patt_imp a l,
"H4" ∶ foldr patt_imp b l,
--------------------------------------
foldr patt_imp (a and b) l
using BasicReasoning

    mlClear "H2".
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Hwf0: well_formed (foldr patt_imp b l)
Γ Ⱶ
"H0" ∶ a0 ---> foldr patt_imp a l,
"H1" ∶ a0 ---> foldr patt_imp b l,
"H3" ∶ foldr patt_imp a l,
"H4" ∶ foldr patt_imp b l,
--------------------------------------
foldr patt_imp (a and b) l
using BasicReasoning
 mlClear "H1".
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Hwf0: well_formed (foldr patt_imp b l)
Γ Ⱶ
"H0" ∶ a0 ---> foldr patt_imp a l,
"H3" ∶ foldr patt_imp a l,
"H4" ∶ foldr patt_imp b l,
--------------------------------------
foldr patt_imp (a and b) l
using BasicReasoning
 mlClear "H0".
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Hwf0: well_formed (foldr patt_imp b l)
Γ Ⱶ
"H3" ∶ foldr patt_imp a l,
"H4" ∶ foldr patt_imp b l,
--------------------------------------
foldr patt_imp (a and b) l
using BasicReasoning

    fromMLGoal.
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ
⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l
using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Hwf0: well_formed (foldr patt_imp b l)
Γ
⊢i foldr patt_imp a l --->
   foldr patt_imp b l ---> foldr patt_imp (a and b) l
using BasicReasoning apply IHl.
Defined.

Lemma prf_conj_split_meta {Σ : Signature} Γ a b l (i : ProofInfo):
  well_formed a ->
  well_formed b ->
  Pattern.wf l ->
  Γ ⊢i (foldr patt_imp a l) using i -> 
  Γ ⊢i (foldr patt_imp b l) ---> (foldr patt_imp (a and b) l) using i.
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo
well_formed a
→ well_formed b
  → Pattern.wf l
    → Γ ⊢i foldr patt_imp a l using i
      → Γ
        ⊢i foldr patt_imp b l --->
           foldr patt_imp (a and b) l using i
Proof.
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo
well_formed a
→ well_formed b
  → Pattern.wf l
    → Γ ⊢i foldr patt_imp a l using i
      → Γ
        ⊢i foldr patt_imp b l --->
           foldr patt_imp (a and b) l using i
  intros.
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo
H: well_formed a
H0: well_formed b
H1: Pattern.wf l
H2: Γ ⊢i foldr patt_imp a l using i
Γ
⊢i foldr patt_imp b l ---> foldr patt_imp (a and b) l
using i eapply MP.
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo
H: well_formed a
H0: well_formed b
H1: Pattern.wf l
H2: Γ ⊢i foldr patt_imp a l using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo
H: well_formed a
H0: well_formed b
H1: Pattern.wf l
H2: Γ ⊢i foldr patt_imp a l using i
Γ
⊢i ?ϕ₁ --->
   foldr patt_imp b l ---> foldr patt_imp (a and b) l
using i 2: {
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo
H: well_formed a
H0: well_formed b
H1: Pattern.wf l
H2: Γ ⊢i foldr patt_imp a l using i
Γ
⊢i ?ϕ₁ --->
   foldr patt_imp b l ---> foldr patt_imp (a and b) l
using i useBasicReasoning.
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo
H: well_formed a
H0: well_formed b
H1: Pattern.wf l
H2: Γ ⊢i foldr patt_imp a l using i
Γ
⊢i ?ϕ₁ --->
   foldr patt_imp b l ---> foldr patt_imp (a and b) l
using BasicReasoning apply prf_conj_split; assumption. }
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo
H: well_formed a
H0: well_formed b
H1: Pattern.wf l
H2: Γ ⊢i foldr patt_imp a l using i
Γ ⊢i foldr patt_imp a l using i
  exact H2.
Defined.

Lemma prf_conj_split_meta_meta {Σ : Signature} Γ a b l (i : ProofInfo):
  well_formed a ->
  well_formed b ->
  Pattern.wf l ->
  Γ ⊢i (foldr patt_imp a l) using i -> 
  Γ ⊢i (foldr patt_imp b l) using i ->
  Γ ⊢i (foldr patt_imp (a and b) l) using i.
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo
well_formed a
→ well_formed b
  → Pattern.wf l
    → Γ ⊢i foldr patt_imp a l using i
      → Γ ⊢i foldr patt_imp b l using i
        → Γ ⊢i foldr patt_imp (a and b) l using i
Proof.
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo
well_formed a
→ well_formed b
  → Pattern.wf l
    → Γ ⊢i foldr patt_imp a l using i
      → Γ ⊢i foldr patt_imp b l using i
        → Γ ⊢i foldr patt_imp (a and b) l using i
  intros.
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo
H: well_formed a
H0: well_formed b
H1: Pattern.wf l
H2: Γ ⊢i foldr patt_imp a l using i
H3: Γ ⊢i foldr patt_imp b l using i
Γ ⊢i foldr patt_imp (a and b) l using i eapply MP.
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo
H: well_formed a
H0: well_formed b
H1: Pattern.wf l
H2: Γ ⊢i foldr patt_imp a l using i
H3: Γ ⊢i foldr patt_imp b l using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo
H: well_formed a
H0: well_formed b
H1: Pattern.wf l
H2: Γ ⊢i foldr patt_imp a l using i
H3: Γ ⊢i foldr patt_imp b l using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp (a and b) l using i
  2: {
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo
H: well_formed a
H0: well_formed b
H1: Pattern.wf l
H2: Γ ⊢i foldr patt_imp a l using i
H3: Γ ⊢i foldr patt_imp b l using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp (a and b) l using i
    apply prf_conj_split_meta; assumption.
  }
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo
H: well_formed a
H0: well_formed b
H1: Pattern.wf l
H2: Γ ⊢i foldr patt_imp a l using i
H3: Γ ⊢i foldr patt_imp b l using i
Γ ⊢i foldr patt_imp b l using i
  exact H3.
Defined.

Lemma MLGoal_splitAnd {Σ : Signature} Γ a b l i:
  mkMLGoal Σ Γ l a i ->
  mkMLGoal Σ Γ l b i ->
  mkMLGoal Σ Γ l (a and b) i.
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Γ Ⱶ
l--------------------------------------
a
using i

→ Γ Ⱶ
  l--------------------------------------
  b
  using i
  
  → Γ Ⱶ
  l--------------------------------------
  a and b
  using i
  
Proof.
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Γ Ⱶ
l--------------------------------------
a
using i

→ Γ Ⱶ
  l--------------------------------------
  b
  using i
  
  → Γ Ⱶ
  l--------------------------------------
  a and b
  using i
  
  intros Ha Hb.
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ Ⱶ
l--------------------------------------
a
using i

Hb: Γ Ⱶ
l--------------------------------------
b
using i

Γ Ⱶ
l--------------------------------------
a and b
using i

  unfold of_MLGoal in *.
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: well_formed
  (mlConclusion
     (Γ Ⱶ
      l--------------------------------------
      a
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l--------------------------------------
           a
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       l--------------------------------------
       a
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l--------------------------------------
             a
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l--------------------------------------
                a
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             l--------------------------------------
             a
             using i
             )
Hb: well_formed
  (mlConclusion
     (Γ Ⱶ
      l--------------------------------------
      b
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l--------------------------------------
           b
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       l--------------------------------------
       b
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l--------------------------------------
             b
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l--------------------------------------
                b
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             l--------------------------------------
             b
             using i
             )
well_formed
  (mlConclusion
     (Γ Ⱶ
      l--------------------------------------
      a and b
      using i
      ))
→ Pattern.wf
    (patterns_of
       (mlHypotheses
          (Γ Ⱶ
           l--------------------------------------
           a and b
           using i
           )))
  → mlTheory
      (Γ Ⱶ
       l--------------------------------------
       a and b
       using i
       )
    ⊢i foldr patt_imp
         (mlConclusion
            (Γ Ⱶ
             l--------------------------------------
             a and b
             using i
             ))
         (patterns_of
            (mlHypotheses
               (Γ Ⱶ
                l--------------------------------------
                a and b
                using i
                )))
    using mlInfo
            (Γ Ⱶ
             l--------------------------------------
             a and b
             using i
             ) simpl in *.
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: well_formed a
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp b (patterns_of l) using i
well_formed (a and b)
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp (a and b) (patterns_of l)
    using i
  intros wfab wfl.
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: well_formed a
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp (a and b) (patterns_of l) using i
  feed specialize Ha.
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: well_formed a
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
well_formed a
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: well_formed a
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp (a and b) (patterns_of l) using i
  {
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: well_formed a
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
well_formed a abstract(wf_auto2). }
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: well_formed a
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp (a and b) (patterns_of l) using i
  {
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: well_formed a
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l) exact wfl. }
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp (a and b) (patterns_of l) using i
  feed specialize Hb.
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
well_formed b
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp (a and b) (patterns_of l) using i
  {
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
well_formed b abstract(wf_auto2). }
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp (a and b) (patterns_of l) using i
  {
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b
→ Pattern.wf (patterns_of l)
  → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l) exact wfl. }
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp (a and b) (patterns_of l) using i
  apply prf_conj_split_meta_meta; auto.
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
well_formed a
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
well_formed b
  {
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
well_formed a abstract (wf_auto2). }
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
well_formed b
  {
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
well_formed b abstract (wf_auto2). }
Defined.

Ltac mlSplitAnd :=
  _ensureProofMode;
  apply MLGoal_splitAnd
.

Local Lemma ex_mlSplitAnd {Σ : Signature} Γ a b c:
  well_formed a ->
  well_formed b ->
  well_formed c ->
  Γ ⊢i a ---> b ---> c ---> (a and b)
  using BasicReasoning.
Σ: Signature
Γ: Theory
a, b, c: Pattern
well_formed a
→ well_formed b
  → well_formed c
    → Γ ⊢i a ---> b ---> c ---> a and b
      using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
a, b, c: Pattern
well_formed a
→ well_formed b
  → well_formed c
    → Γ ⊢i a ---> b ---> c ---> a and b
      using BasicReasoning
  intros wfa wfb wfc.
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ ⊢i a ---> b ---> c ---> a and b using BasicReasoning
  toMLGoal.
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
well_formed (a ---> b ---> c ---> a and b)
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ Ⱶ
a ---> b ---> c ---> a and b
using BasicReasoning

  {
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
well_formed (a ---> b ---> c ---> a and b) wf_auto2. }
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ Ⱶ
a ---> b ---> c ---> a and b
using BasicReasoning

  mlIntro "H0".
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ Ⱶ
"H0" ∶ a,
--------------------------------------
b ---> c ---> a and b
using BasicReasoning
 mlIntro "H1".
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ b,
--------------------------------------
c ---> a and b
using BasicReasoning
 mlIntro "H2".
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ b,
"H2" ∶ c,
--------------------------------------
a and b
using BasicReasoning

  mlSplitAnd.
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ b,
"H2" ∶ c,
--------------------------------------
a
using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ b,
"H2" ∶ c,
--------------------------------------
b
using BasicReasoning

  -
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ b,
"H2" ∶ c,
--------------------------------------
a
using BasicReasoning
 mlExact "H0".
  -
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ Ⱶ
"H0" ∶ a,
"H1" ∶ b,
"H2" ∶ c,
--------------------------------------
b
using BasicReasoning
 mlExact "H1".
Defined.

Lemma prf_local_goals_equiv_impl_full_equiv {Σ : Signature} Γ g₁ g₂ l:
  well_formed g₁ ->
  well_formed g₂ ->
  Pattern.wf l ->
  Γ ⊢i (foldr patt_imp (g₁ <---> g₂) l) --->
      ((foldr patt_imp g₁ l) <---> (foldr patt_imp g₂ l))
  using BasicReasoning.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
well_formed g₁
→ well_formed g₂
  → Pattern.wf l
    → Γ
      ⊢i foldr patt_imp (g₁ <---> g₂) l --->
         foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
      using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
well_formed g₁
→ well_formed g₂
  → Pattern.wf l
    → Γ
      ⊢i foldr patt_imp (g₁ <---> g₂) l --->
         foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
      using BasicReasoning
  intros wfg₁ wfg₂ wfl.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
  induction l; simpl.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf []
Γ ⊢i g₁ <---> g₂ ---> g₁ <---> g₂ using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Pattern.wf l
→ Γ
  ⊢i foldr patt_imp (g₁ <---> g₂) l --->
     foldr patt_imp g₁ l <--->
     foldr patt_imp g₂ l using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp (g₁ <---> g₂) l) --->
   (a ---> foldr patt_imp g₁ l) <--->
   (a ---> foldr patt_imp g₂ l) using BasicReasoning
  -
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf []
Γ ⊢i g₁ <---> g₂ ---> g₁ <---> g₂ using BasicReasoning apply A_impl_A; wf_auto2.
  -
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Pattern.wf l
→ Γ
  ⊢i foldr patt_imp (g₁ <---> g₂) l --->
     foldr patt_imp g₁ l <--->
     foldr patt_imp g₂ l using BasicReasoning
Γ
⊢i (a ---> foldr patt_imp (g₁ <---> g₂) l) --->
   (a ---> foldr patt_imp g₁ l) <--->
   (a ---> foldr patt_imp g₂ l) using BasicReasoning pose proof (wfl' := wfl).
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Pattern.wf l
→ Γ
  ⊢i foldr patt_imp (g₁ <---> g₂) l --->
     foldr patt_imp g₁ l <--->
     foldr patt_imp g₂ l using BasicReasoning
wfl': Pattern.wf (a :: l)
Γ
⊢i (a ---> foldr patt_imp (g₁ <---> g₂) l) --->
   (a ---> foldr patt_imp g₁ l) <--->
   (a ---> foldr patt_imp g₂ l) using BasicReasoning unfold Pattern.wf in wfl'.
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Pattern.wf l
→ Γ
  ⊢i foldr patt_imp (g₁ <---> g₂) l --->
     foldr patt_imp g₁ l <--->
     foldr patt_imp g₂ l using BasicReasoning
wfl': foldr andb true (map well_formed (a :: l))
Γ
⊢i (a ---> foldr patt_imp (g₁ <---> g₂) l) --->
   (a ---> foldr patt_imp g₁ l) <--->
   (a ---> foldr patt_imp g₂ l) using BasicReasoning simpl in wfl'.
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Pattern.wf l
→ Γ
  ⊢i foldr patt_imp (g₁ <---> g₂) l --->
     foldr patt_imp g₁ l <--->
     foldr patt_imp g₂ l using BasicReasoning
wfl': well_formed a &&
foldr andb true (map well_formed l)
Γ
⊢i (a ---> foldr patt_imp (g₁ <---> g₂) l) --->
   (a ---> foldr patt_imp g₁ l) <--->
   (a ---> foldr patt_imp g₂ l) using BasicReasoning apply andb_prop in wfl' as [wfa wfl'].
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Pattern.wf l
→ Γ
  ⊢i foldr patt_imp (g₁ <---> g₂) l --->
     foldr patt_imp g₁ l <--->
     foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ
⊢i (a ---> foldr patt_imp (g₁ <---> g₂) l) --->
   (a ---> foldr patt_imp g₁ l) <--->
   (a ---> foldr patt_imp g₂ l) using BasicReasoning
    specialize (IHl wfl').
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ
⊢i (a ---> foldr patt_imp (g₁ <---> g₂) l) --->
   (a ---> foldr patt_imp g₁ l) <--->
   (a ---> foldr patt_imp g₂ l) using BasicReasoning
    toMLGoal.
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
well_formed
  ((a ---> foldr patt_imp (g₁ <---> g₂) l) --->
   (a ---> foldr patt_imp g₁ l) <--->
   (a ---> foldr patt_imp g₂ l))
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
(a ---> foldr patt_imp (g₁ <---> g₂) l) --->
(a ---> foldr patt_imp g₁ l) <--->
(a ---> foldr patt_imp g₂ l)
using BasicReasoning

    {
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
well_formed
  ((a ---> foldr patt_imp (g₁ <---> g₂) l) --->
   (a ---> foldr patt_imp g₁ l) <--->
   (a ---> foldr patt_imp g₂ l)) wf_auto2. }
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
(a ---> foldr patt_imp (g₁ <---> g₂) l) --->
(a ---> foldr patt_imp g₁ l) <--->
(a ---> foldr patt_imp g₂ l)
using BasicReasoning

    mlIntro "H0".
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
"H0" ∶ a ---> foldr patt_imp (g₁ <---> g₂) l,
--------------------------------------
(a ---> foldr patt_imp g₁ l) <--->
(a ---> foldr patt_imp g₂ l)
using BasicReasoning
 mlSplitAnd.
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
"H0" ∶ a ---> foldr patt_imp (g₁ <---> g₂) l,
--------------------------------------
(a ---> foldr patt_imp g₁ l) --->
a ---> foldr patt_imp g₂ l
using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
"H0" ∶ a ---> foldr patt_imp (g₁ <---> g₂) l,
--------------------------------------
(a ---> foldr patt_imp g₂ l) --->
a ---> foldr patt_imp g₁ l
using BasicReasoning

    +
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
"H0" ∶ a ---> foldr patt_imp (g₁ <---> g₂) l,
--------------------------------------
(a ---> foldr patt_imp g₁ l) --->
a ---> foldr patt_imp g₂ l
using BasicReasoning
 mlApplyMeta P2.
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
"H0" ∶ a ---> foldr patt_imp (g₁ <---> g₂) l,
--------------------------------------
a ---> foldr patt_imp g₁ l ---> foldr patt_imp g₂ l
using BasicReasoning

      mlRevertLast.
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
(a ---> foldr patt_imp (g₁ <---> g₂) l) --->
a ---> foldr patt_imp g₁ l ---> foldr patt_imp g₂ l
using BasicReasoning

      mlApplyMeta P2.
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
a --->
foldr patt_imp (g₁ <---> g₂) l --->
foldr patt_imp g₁ l ---> foldr patt_imp g₂ l
using BasicReasoning

      mlIntro "H0".
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
"H0" ∶ a,
--------------------------------------
foldr patt_imp (g₁ <---> g₂) l --->
foldr patt_imp g₁ l ---> foldr patt_imp g₂ l
using BasicReasoning
 mlClear "H0".
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
foldr patt_imp (g₁ <---> g₂) l --->
foldr patt_imp g₁ l ---> foldr patt_imp g₂ l
using BasicReasoning
 mlIntro "H0".
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
"H0" ∶ foldr patt_imp (g₁ <---> g₂) l,
--------------------------------------
foldr patt_imp g₁ l ---> foldr patt_imp g₂ l
using BasicReasoning

      mlApplyMeta IHl in "H0".
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
"H0" ∶ foldr patt_imp g₁ l <---> foldr patt_imp g₂ l,
--------------------------------------
foldr patt_imp g₁ l ---> foldr patt_imp g₂ l
using BasicReasoning

      unfold patt_iff at 1.
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
"H0" ∶ (foldr patt_imp g₁ l ---> foldr patt_imp g₂ l)
       and (foldr patt_imp g₂ l --->
            foldr patt_imp g₁ l),
--------------------------------------
foldr patt_imp g₁ l ---> foldr patt_imp g₂ l
using BasicReasoning
 mlDestructAnd "H0" as "H1" "H2".
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
"H1" ∶ foldr patt_imp g₁ l ---> foldr patt_imp g₂ l,
"H2" ∶ foldr patt_imp g₂ l ---> foldr patt_imp g₁ l,
--------------------------------------
foldr patt_imp g₁ l ---> foldr patt_imp g₂ l
using BasicReasoning

      mlExact "H1".
    +
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
"H0" ∶ a ---> foldr patt_imp (g₁ <---> g₂) l,
--------------------------------------
(a ---> foldr patt_imp g₂ l) --->
a ---> foldr patt_imp g₁ l
using BasicReasoning
 mlApplyMeta P2.
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
"H0" ∶ a ---> foldr patt_imp (g₁ <---> g₂) l,
--------------------------------------
a ---> foldr patt_imp g₂ l ---> foldr patt_imp g₁ l
using BasicReasoning

      mlRevertLast.
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
(a ---> foldr patt_imp (g₁ <---> g₂) l) --->
a ---> foldr patt_imp g₂ l ---> foldr patt_imp g₁ l
using BasicReasoning

      mlApplyMeta P2.
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
a --->
foldr patt_imp (g₁ <---> g₂) l --->
foldr patt_imp g₂ l ---> foldr patt_imp g₁ l
using BasicReasoning

      mlIntro "H0".
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
"H0" ∶ a,
--------------------------------------
foldr patt_imp (g₁ <---> g₂) l --->
foldr patt_imp g₂ l ---> foldr patt_imp g₁ l
using BasicReasoning
 mlClear "H0".
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
foldr patt_imp (g₁ <---> g₂) l --->
foldr patt_imp g₂ l ---> foldr patt_imp g₁ l
using BasicReasoning
 mlIntro "H0".
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
"H0" ∶ foldr patt_imp (g₁ <---> g₂) l,
--------------------------------------
foldr patt_imp g₂ l ---> foldr patt_imp g₁ l
using BasicReasoning

      mlApplyMeta IHl in "H0".
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
"H0" ∶ foldr patt_imp g₁ l <---> foldr patt_imp g₂ l,
--------------------------------------
foldr patt_imp g₂ l ---> foldr patt_imp g₁ l
using BasicReasoning

      unfold patt_iff at 1.
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
"H0" ∶ (foldr patt_imp g₁ l ---> foldr patt_imp g₂ l)
       and (foldr patt_imp g₂ l --->
            foldr patt_imp g₁ l),
--------------------------------------
foldr patt_imp g₂ l ---> foldr patt_imp g₁ l
using BasicReasoning
 mlDestructAnd "H0" as "H1" "H2".
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ
⊢i foldr patt_imp (g₁ <---> g₂) l --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ
"H1" ∶ foldr patt_imp g₁ l ---> foldr patt_imp g₂ l,
"H2" ∶ foldr patt_imp g₂ l ---> foldr patt_imp g₁ l,
--------------------------------------
foldr patt_imp g₂ l ---> foldr patt_imp g₁ l
using BasicReasoning

      mlExact "H2".
Defined.

Lemma prf_local_goals_equiv_impl_full_equiv_meta {Σ : Signature} Γ g₁ g₂ l i:
  well_formed g₁ ->
  well_formed g₂ ->
  Pattern.wf l ->
  Γ ⊢i (foldr patt_imp (g₁ <---> g₂) l) using i ->
  Γ ⊢i ((foldr patt_imp g₁ l) <---> (foldr patt_imp g₂ l)) using i.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
well_formed g₁
→ well_formed g₂
  → Pattern.wf l
    → Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
      → Γ
        ⊢i foldr patt_imp g₁ l <--->
           foldr patt_imp g₂ l using i
Proof.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
well_formed g₁
→ well_formed g₂
  → Pattern.wf l
    → Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
      → Γ
        ⊢i foldr patt_imp g₁ l <--->
           foldr patt_imp g₂ l using i
  intros wfg₁ wfg₂ wfl H.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
Γ ⊢i foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using i
  eapply MP.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
Γ
⊢i ?ϕ₁ --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using i
  2: {
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
Γ
⊢i ?ϕ₁ --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using i useBasicReasoning.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
Γ
⊢i ?ϕ₁ --->
   foldr patt_imp g₁ l <---> foldr patt_imp g₂ l
using BasicReasoning apply prf_local_goals_equiv_impl_full_equiv; assumption. }
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
  exact H.
Defined.

Lemma prf_local_goals_equiv_impl_full_equiv_meta_proj1 {Σ : Signature} Γ g₁ g₂ l i:
  well_formed g₁ ->
  well_formed g₂ ->
  Pattern.wf l ->
  Γ ⊢i (foldr patt_imp (g₁ <---> g₂) l) using i ->
  Γ ⊢i (foldr patt_imp g₁ l) using i ->
  Γ ⊢i (foldr patt_imp g₂ l) using i.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
well_formed g₁
→ well_formed g₂
  → Pattern.wf l
    → Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
      → Γ ⊢i foldr patt_imp g₁ l using i
        → Γ ⊢i foldr patt_imp g₂ l using i
Proof.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
well_formed g₁
→ well_formed g₂
  → Pattern.wf l
    → Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
      → Γ ⊢i foldr patt_imp g₁ l using i
        → Γ ⊢i foldr patt_imp g₂ l using i
  intros wfg₁ wfg₂ wfl H1 H2.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
Γ ⊢i foldr patt_imp g₂ l using i
  eapply MP.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp g₂ l using i
  2: eapply pf_iff_proj1.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
well_formed ?ϕ₁
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
well_formed (foldr patt_imp g₂ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
Γ ⊢i ?ϕ₁ <---> foldr patt_imp g₂ l using i
  4: apply prf_local_goals_equiv_impl_full_equiv_meta.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
Γ ⊢i foldr patt_imp ?g₁ l using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
well_formed (foldr patt_imp ?g₁ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
well_formed (foldr patt_imp g₂ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
well_formed ?g₁
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
well_formed g₂
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
Pattern.wf l
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
Γ ⊢i foldr patt_imp (?g₁ <---> g₂) l using i
  7: apply H1.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
Γ ⊢i foldr patt_imp g₁ l using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
well_formed (foldr patt_imp g₁ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
well_formed (foldr patt_imp g₂ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
well_formed g₁
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
well_formed g₂
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
Pattern.wf l
  1: exact H2.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
well_formed (foldr patt_imp g₁ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
well_formed (foldr patt_imp g₂ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
well_formed g₁
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
well_formed g₂
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
Pattern.wf l
  all: wf_auto2.
Defined.

Lemma prf_local_goals_equiv_impl_full_equiv_meta_proj2 {Σ : Signature} Γ g₁ g₂ l i:
  well_formed g₁ ->
  well_formed g₂ ->
  Pattern.wf l ->
  Γ ⊢i (foldr patt_imp (g₁ <---> g₂) l) using i ->
  Γ ⊢i (foldr patt_imp g₂ l) using i ->
  Γ ⊢i (foldr patt_imp g₁ l) using i.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
well_formed g₁
→ well_formed g₂
  → Pattern.wf l
    → Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
      → Γ ⊢i foldr patt_imp g₂ l using i
        → Γ ⊢i foldr patt_imp g₁ l using i
Proof.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
well_formed g₁
→ well_formed g₂
  → Pattern.wf l
    → Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
      → Γ ⊢i foldr patt_imp g₂ l using i
        → Γ ⊢i foldr patt_imp g₁ l using i
  intros wfg₁ wfg₂ wfl H1 H2.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
Γ ⊢i foldr patt_imp g₁ l using i
  eapply MP.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp g₁ l using i
  2: eapply pf_iff_proj2.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
well_formed (foldr patt_imp g₁ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
well_formed ?ϕ₁
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
Γ ⊢i foldr patt_imp g₁ l <---> ?ϕ₁ using i
  4: apply prf_local_goals_equiv_impl_full_equiv_meta.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
Γ ⊢i foldr patt_imp ?g₂ l using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
well_formed (foldr patt_imp g₁ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
well_formed (foldr patt_imp ?g₂ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
well_formed g₁
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
well_formed ?g₂
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
Pattern.wf l
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
Γ ⊢i foldr patt_imp (g₁ <---> ?g₂) l using i
  7: apply H1.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
Γ ⊢i foldr patt_imp g₂ l using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
well_formed (foldr patt_imp g₁ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
well_formed (foldr patt_imp g₂ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
well_formed g₁
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
well_formed g₂
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
Pattern.wf l
  1: exact H2.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
well_formed (foldr patt_imp g₁ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
well_formed (foldr patt_imp g₂ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
well_formed g₁
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
well_formed g₂
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
Pattern.wf l
  all: wf_auto2.
Defined.



Lemma top_holds {Σ : Signature} Γ:
  Γ ⊢i Top using BasicReasoning.
Σ: Signature
Γ: Theory
Γ ⊢i Top using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
Γ ⊢i Top using BasicReasoning
  apply bot_elim.
Σ: Signature
Γ: Theory
well_formed ⊥
  {
Σ: Signature
Γ: Theory
well_formed ⊥ wf_auto2. }
Defined.

Lemma phi_iff_phi_top {Σ : Signature} Γ ϕ :
  well_formed ϕ ->
  Γ ⊢i ϕ <---> (ϕ <---> Top)
  using BasicReasoning.
Σ: Signature
Γ: Theory
ϕ: Pattern
well_formed ϕ
→ Γ ⊢i ϕ <---> (ϕ <---> Top) using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
ϕ: Pattern
well_formed ϕ
→ Γ ⊢i ϕ <---> (ϕ <---> Top) using BasicReasoning
  intros wfϕ.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ ⊢i ϕ <---> (ϕ <---> Top) using BasicReasoning
  toMLGoal.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
well_formed (ϕ <---> (ϕ <---> Top))
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
ϕ <---> (ϕ <---> Top)
using BasicReasoning

  {
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
well_formed (ϕ <---> (ϕ <---> Top)) wf_auto2. }
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
ϕ <---> (ϕ <---> Top)
using BasicReasoning

  mlSplitAnd; mlIntro "H0".
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H0" ∶ ϕ,
--------------------------------------
ϕ <---> Top
using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H0" ∶ ϕ <---> Top,
--------------------------------------
ϕ
using BasicReasoning

  -
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H0" ∶ ϕ,
--------------------------------------
ϕ <---> Top
using BasicReasoning
 mlSplitAnd.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H0" ∶ ϕ,
--------------------------------------
ϕ ---> Top
using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H0" ∶ ϕ,
--------------------------------------
Top ---> ϕ
using BasicReasoning

    +
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H0" ∶ ϕ,
--------------------------------------
ϕ ---> Top
using BasicReasoning
 mlIntro "H1".
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H0" ∶ ϕ,
"H1" ∶ ϕ,
--------------------------------------
Top
using BasicReasoning
 mlClear "H1".
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H0" ∶ ϕ,
--------------------------------------
Top
using BasicReasoning
 mlClear "H0".
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
Top
using BasicReasoning

      fromMLGoal.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ ⊢i Top using BasicReasoning
      apply top_holds. (* TODO: we need something like [mlExactMeta top_holds] *)
    +
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H0" ∶ ϕ,
--------------------------------------
Top ---> ϕ
using BasicReasoning
 fromMLGoal.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ ⊢i ϕ ---> Top ---> ϕ using BasicReasoning
      apply P1; wf_auto2.
  -
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H0" ∶ ϕ <---> Top,
--------------------------------------
ϕ
using BasicReasoning
 mlDestructAnd "H0" as "H1" "H2".
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H1" ∶ ϕ ---> Top,
"H2" ∶ Top ---> ϕ,
--------------------------------------
ϕ
using BasicReasoning

    mlApply "H2".
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H1" ∶ ϕ ---> Top,
"H2" ∶ Top ---> ϕ,
--------------------------------------
Top
using BasicReasoning

    mlClear "H2".
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H1" ∶ ϕ ---> Top,
--------------------------------------
Top
using BasicReasoning

    mlClear "H1".
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
Top
using BasicReasoning

    fromMLGoal.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ ⊢i Top using BasicReasoning
    apply top_holds.
Defined.

Lemma not_phi_iff_phi_bott {Σ : Signature} Γ ϕ :
  well_formed ϕ ->
  Γ ⊢i (! ϕ ) <---> (ϕ <---> ⊥)
  using BasicReasoning.
Σ: Signature
Γ: Theory
ϕ: Pattern
well_formed ϕ
→ Γ ⊢i ! ϕ <---> (ϕ <---> ⊥) using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
ϕ: Pattern
well_formed ϕ
→ Γ ⊢i ! ϕ <---> (ϕ <---> ⊥) using BasicReasoning
  intros wfϕ.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ ⊢i ! ϕ <---> (ϕ <---> ⊥) using BasicReasoning
  toMLGoal.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
well_formed (! ϕ <---> (ϕ <---> ⊥))
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
! ϕ <---> (ϕ <---> ⊥)
using BasicReasoning

  {
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
well_formed (! ϕ <---> (ϕ <---> ⊥)) wf_auto2. }
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
! ϕ <---> (ϕ <---> ⊥)
using BasicReasoning

  mlSplitAnd; mlIntro "H0".
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H0" ∶ ! ϕ,
--------------------------------------
ϕ <---> ⊥
using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H0" ∶ ϕ <---> ⊥,
--------------------------------------
! ϕ
using BasicReasoning

  -
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H0" ∶ ! ϕ,
--------------------------------------
ϕ <---> ⊥
using BasicReasoning
 mlSplitAnd.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H0" ∶ ! ϕ,
--------------------------------------
ϕ ---> ⊥
using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H0" ∶ ! ϕ,
--------------------------------------
⊥ ---> ϕ
using BasicReasoning

    +
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H0" ∶ ! ϕ,
--------------------------------------
ϕ ---> ⊥
using BasicReasoning
 mlExact "H0".
    +
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H0" ∶ ! ϕ,
--------------------------------------
⊥ ---> ϕ
using BasicReasoning
 mlClear "H0".
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
⊥ ---> ϕ
using BasicReasoning
 fromMLGoal.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ ⊢i ⊥ ---> ϕ using BasicReasoning
      apply bot_elim.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
well_formed ϕ
      {
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
well_formed ϕ wf_auto2. }
  -
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H0" ∶ ϕ <---> ⊥,
--------------------------------------
! ϕ
using BasicReasoning
 mlDestructAnd "H0" as "H1" "H2".
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H1" ∶ ϕ ---> ⊥,
"H2" ∶ ⊥ ---> ϕ,
--------------------------------------
! ϕ
using BasicReasoning

    mlExact "H1".
Defined.

Lemma not_not_iff {Σ : Signature} (Γ : Theory) (A : Pattern) :
  well_formed A ->
  Γ ⊢i A <---> ! ! A
  using BasicReasoning.
Σ: Signature
Γ: Theory
A: Pattern
well_formed A
→ Γ ⊢i A <---> ! ! A using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
A: Pattern
well_formed A
→ Γ ⊢i A <---> ! ! A using BasicReasoning
  intros wfA.
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
Γ ⊢i A <---> ! ! A using BasicReasoning
  apply pf_iff_split.
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
well_formed A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
well_formed (! ! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
Γ ⊢i A ---> ! ! A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
Γ ⊢i ! ! A ---> A using BasicReasoning
  {
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
well_formed A wf_auto2. }
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
well_formed (! ! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
Γ ⊢i A ---> ! ! A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
Γ ⊢i ! ! A ---> A using BasicReasoning
  {
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
well_formed (! ! A) wf_auto2. }
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
Γ ⊢i A ---> ! ! A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
Γ ⊢i ! ! A ---> A using BasicReasoning
  -
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
Γ ⊢i A ---> ! ! A using BasicReasoning apply not_not_intro.
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
well_formed A
    {
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
well_formed A wf_auto2. }
  -
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
Γ ⊢i ! ! A ---> A using BasicReasoning apply not_not_elim.
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
well_formed A
    {
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
well_formed A wf_auto2. }
Defined.


Lemma patt_and_comm {Σ : Signature} Γ p q:
  well_formed p ->
  well_formed q ->
  Γ ⊢i (p and q) <---> (q and p)
  using BasicReasoning.
Σ: Signature
Γ: Theory
p, q: Pattern
well_formed p
→ well_formed q
  → Γ ⊢i p and q <---> q and p using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
p, q: Pattern
well_formed p
→ well_formed q
  → Γ ⊢i p and q <---> q and p using BasicReasoning
  intros wfp wfq.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ ⊢i p and q <---> q and p using BasicReasoning
  toMLGoal.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
well_formed (p and q <---> q and p)
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
p and q <---> q and p
using BasicReasoning

  {
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
well_formed (p and q <---> q and p) wf_auto2. }
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
p and q <---> q and p
using BasicReasoning

  mlSplitAnd; mlIntro "H0"; mlDestructAnd "H0" as "H1" "H2"; mlSplitAnd.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
"H1" ∶ p,
"H2" ∶ q,
--------------------------------------
q
using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
"H1" ∶ p,
"H2" ∶ q,
--------------------------------------
p
using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
"H1" ∶ q,
"H2" ∶ p,
--------------------------------------
p
using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
"H1" ∶ q,
"H2" ∶ p,
--------------------------------------
q
using BasicReasoning

  -
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
"H1" ∶ p,
"H2" ∶ q,
--------------------------------------
q
using BasicReasoning
 mlExact "H2".
  -
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
"H1" ∶ p,
"H2" ∶ q,
--------------------------------------
p
using BasicReasoning
 mlExact "H1".
  -
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
"H1" ∶ q,
"H2" ∶ p,
--------------------------------------
p
using BasicReasoning
 mlExact "H2".
  -
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ
"H1" ∶ q,
"H2" ∶ p,
--------------------------------------
q
using BasicReasoning
 mlExact "H1".
Defined.



(* We need to come up with tactics that make this easier. *)
Local Example ex_mt {Σ : Signature} Γ ϕ₁ ϕ₂:
  well_formed ϕ₁ ->
  well_formed ϕ₂ ->
  Γ ⊢i (! ϕ₁ ---> ! ϕ₂) ---> (ϕ₂ ---> ϕ₁)
  using BasicReasoning.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
well_formed ϕ₁
→ well_formed ϕ₂
  → Γ ⊢i (! ϕ₁ ---> ! ϕ₂) ---> ϕ₂ ---> ϕ₁
    using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
well_formed ϕ₁
→ well_formed ϕ₂
  → Γ ⊢i (! ϕ₁ ---> ! ϕ₂) ---> ϕ₂ ---> ϕ₁
    using BasicReasoning
  intros wfϕ₁ wfϕ₂.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Γ ⊢i (! ϕ₁ ---> ! ϕ₂) ---> ϕ₂ ---> ϕ₁
using BasicReasoning
  toMLGoal.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
well_formed ((! ϕ₁ ---> ! ϕ₂) ---> ϕ₂ ---> ϕ₁)
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Γ Ⱶ
(! ϕ₁ ---> ! ϕ₂) ---> ϕ₂ ---> ϕ₁
using BasicReasoning

  {
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
well_formed ((! ϕ₁ ---> ! ϕ₂) ---> ϕ₂ ---> ϕ₁) wf_auto2. }
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Γ Ⱶ
(! ϕ₁ ---> ! ϕ₂) ---> ϕ₂ ---> ϕ₁
using BasicReasoning

  mlIntro "H0".
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Γ Ⱶ
"H0" ∶ ! ϕ₁ ---> ! ϕ₂,
--------------------------------------
ϕ₂ ---> ϕ₁
using BasicReasoning
 mlIntro "H1".
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Γ Ⱶ
"H0" ∶ ! ϕ₁ ---> ! ϕ₂,
"H1" ∶ ϕ₂,
--------------------------------------
ϕ₁
using BasicReasoning

  unfold patt_not.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Γ Ⱶ
"H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥,
"H1" ∶ ϕ₂,
--------------------------------------
ϕ₁
using BasicReasoning

  mlAssert ("H2" : ((ϕ₁ ---> ⊥) ---> ⊥)).
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Γ Ⱶ
"H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥,
"H1" ∶ ϕ₂,
--------------------------------------
(ϕ₁ ---> ⊥) ---> ⊥
using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Γ Ⱶ
"H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥,
"H1" ∶ ϕ₂,
"H2" ∶ (ϕ₁ ---> ⊥) ---> ⊥,
--------------------------------------
ϕ₁
using BasicReasoning

  {
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
well_formed ((ϕ₁ ---> ⊥) ---> ⊥) wf_auto2. }
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Γ Ⱶ
"H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥,
"H1" ∶ ϕ₂,
--------------------------------------
(ϕ₁ ---> ⊥) ---> ⊥
using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Γ Ⱶ
"H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥,
"H1" ∶ ϕ₂,
"H2" ∶ (ϕ₁ ---> ⊥) ---> ⊥,
--------------------------------------
ϕ₁
using BasicReasoning

  {
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Γ Ⱶ
"H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥,
"H1" ∶ ϕ₂,
--------------------------------------
(ϕ₁ ---> ⊥) ---> ⊥
using BasicReasoning
 mlIntro "H2".
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Γ Ⱶ
"H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥,
"H1" ∶ ϕ₂,
"H2" ∶ ϕ₁ ---> ⊥,
--------------------------------------
⊥
using BasicReasoning

    mlAssert ("H3" : (ϕ₂ ---> ⊥)).
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
well_formed (ϕ₂ ---> ⊥)
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Hwf0: well_formed (ϕ₂ ---> ⊥)
Γ Ⱶ
"H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥,
"H1" ∶ ϕ₂,
"H2" ∶ ϕ₁ ---> ⊥,
--------------------------------------
ϕ₂ ---> ⊥
using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Hwf0: well_formed (ϕ₂ ---> ⊥)
Γ Ⱶ
"H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥,
"H1" ∶ ϕ₂,
"H2" ∶ ϕ₁ ---> ⊥,
"H3" ∶ ϕ₂ ---> ⊥,
--------------------------------------
⊥
using BasicReasoning

    {
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
well_formed (ϕ₂ ---> ⊥) wf_auto2. }
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Hwf0: well_formed (ϕ₂ ---> ⊥)
Γ Ⱶ
"H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥,
"H1" ∶ ϕ₂,
"H2" ∶ ϕ₁ ---> ⊥,
--------------------------------------
ϕ₂ ---> ⊥
using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Hwf0: well_formed (ϕ₂ ---> ⊥)
Γ Ⱶ
"H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥,
"H1" ∶ ϕ₂,
"H2" ∶ ϕ₁ ---> ⊥,
"H3" ∶ ϕ₂ ---> ⊥,
--------------------------------------
⊥
using BasicReasoning

    {
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Hwf0: well_formed (ϕ₂ ---> ⊥)
Γ Ⱶ
"H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥,
"H1" ∶ ϕ₂,
"H2" ∶ ϕ₁ ---> ⊥,
--------------------------------------
ϕ₂ ---> ⊥
using BasicReasoning
 mlApply "H0".
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Hwf0: well_formed (ϕ₂ ---> ⊥)
Γ Ⱶ
"H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥,
"H1" ∶ ϕ₂,
"H2" ∶ ϕ₁ ---> ⊥,
--------------------------------------
ϕ₁ ---> ⊥
using BasicReasoning
 mlExact "H2". }
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Hwf0: well_formed (ϕ₂ ---> ⊥)
Γ Ⱶ
"H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥,
"H1" ∶ ϕ₂,
"H2" ∶ ϕ₁ ---> ⊥,
"H3" ∶ ϕ₂ ---> ⊥,
--------------------------------------
⊥
using BasicReasoning

    mlApply "H3".
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Hwf0: well_formed (ϕ₂ ---> ⊥)
Γ Ⱶ
"H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥,
"H1" ∶ ϕ₂,
"H2" ∶ ϕ₁ ---> ⊥,
"H3" ∶ ϕ₂ ---> ⊥,
--------------------------------------
ϕ₂
using BasicReasoning

    mlExact "H1".
  }
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Γ Ⱶ
"H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥,
"H1" ∶ ϕ₂,
"H2" ∶ (ϕ₁ ---> ⊥) ---> ⊥,
--------------------------------------
ϕ₁
using BasicReasoning

  mlApplyMeta not_not_elim.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Γ Ⱶ
"H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥,
"H1" ∶ ϕ₂,
"H2" ∶ (ϕ₁ ---> ⊥) ---> ⊥,
--------------------------------------
! ! ϕ₁
using BasicReasoning

  mlExact "H2".
Defined.

Lemma lhs_and_to_imp {Σ : Signature} Γ (g x : Pattern) (xs : list Pattern):
  well_formed g ->
  well_formed x ->
  Pattern.wf xs ->
  Γ ⊢i (foldr patt_and x xs ---> g) ---> (foldr patt_imp g (x :: xs))
  using BasicReasoning.
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
well_formed g
→ well_formed x
  → Pattern.wf xs
    → Γ
      ⊢i (foldr patt_and x xs ---> g) --->
         foldr patt_imp g (x :: xs)
      using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
well_formed g
→ well_formed x
  → Pattern.wf xs
    → Γ
      ⊢i (foldr patt_and x xs ---> g) --->
         foldr patt_imp g (x :: xs)
      using BasicReasoning
  intros wfg wfx wfxs.
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs
Γ
⊢i (foldr patt_and x xs ---> g) --->
   foldr patt_imp g (x :: xs) using BasicReasoning
  induction xs; simpl.
Σ: Signature
Γ: Theory
g, x: Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf []
Γ ⊢i (x ---> g) ---> x ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs
→ Γ
  ⊢i (foldr patt_and x xs ---> g) --->
     foldr patt_imp g (x :: xs)
  using BasicReasoning
Γ
⊢i (a and foldr patt_and x xs ---> g) --->
   x ---> a ---> foldr patt_imp g xs
using BasicReasoning
  -
Σ: Signature
Γ: Theory
g, x: Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf []
Γ ⊢i (x ---> g) ---> x ---> g using BasicReasoning apply A_impl_A.
Σ: Signature
Γ: Theory
g, x: Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf []
well_formed (x ---> g)
    {
Σ: Signature
Γ: Theory
g, x: Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf []
well_formed (x ---> g) wf_auto2. }
  -
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs
→ Γ
  ⊢i (foldr patt_and x xs ---> g) --->
     foldr patt_imp g (x :: xs)
  using BasicReasoning
Γ
⊢i (a and foldr patt_and x xs ---> g) --->
   x ---> a ---> foldr patt_imp g xs
using BasicReasoning pose proof (wfaxs := wfxs).
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs
→ Γ
  ⊢i (foldr patt_and x xs ---> g) --->
     foldr patt_imp g (x :: xs)
  using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Γ
⊢i (a and foldr patt_and x xs ---> g) --->
   x ---> a ---> foldr patt_imp g xs
using BasicReasoning
    unfold Pattern.wf in wfxs.
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: foldr andb true (map well_formed (a :: xs))
IHxs: Pattern.wf xs
→ Γ
  ⊢i (foldr patt_and x xs ---> g) --->
     foldr patt_imp g (x :: xs)
  using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Γ
⊢i (a and foldr patt_and x xs ---> g) --->
   x ---> a ---> foldr patt_imp g xs
using BasicReasoning
    simpl in wfxs.
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: well_formed a &&
foldr andb true (map well_formed xs)
IHxs: Pattern.wf xs
→ Γ
  ⊢i (foldr patt_and x xs ---> g) --->
     foldr patt_imp g (x :: xs)
  using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Γ
⊢i (a and foldr patt_and x xs ---> g) --->
   x ---> a ---> foldr patt_imp g xs
using BasicReasoning
    apply andb_prop in wfxs as [wfa wfxs].
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: foldr andb true (map well_formed xs) = true
IHxs: Pattern.wf xs
→ Γ
  ⊢i (foldr patt_and x xs ---> g) --->
     foldr patt_imp g (x :: xs)
  using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Γ
⊢i (a and foldr patt_and x xs ---> g) --->
   x ---> a ---> foldr patt_imp g xs
using BasicReasoning
    fold (Pattern.wf xs) in wfxs.
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Pattern.wf xs
→ Γ
  ⊢i (foldr patt_and x xs ---> g) --->
     foldr patt_imp g (x :: xs)
  using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Γ
⊢i (a and foldr patt_and x xs ---> g) --->
   x ---> a ---> foldr patt_imp g xs
using BasicReasoning
    specialize (IHxs wfxs).
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   foldr patt_imp g (x :: xs)
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Γ
⊢i (a and foldr patt_and x xs ---> g) --->
   x ---> a ---> foldr patt_imp g xs
using BasicReasoning
    simpl in IHxs.
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Γ
⊢i (a and foldr patt_and x xs ---> g) --->
   x ---> a ---> foldr patt_imp g xs
using BasicReasoning
    assert (Hwffa: well_formed (foldr patt_and x xs)).
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
well_formed (foldr patt_and x xs)
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Γ
⊢i (a and foldr patt_and x xs ---> g) --->
   x ---> a ---> foldr patt_imp g xs
using BasicReasoning
    {
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
well_formed (foldr patt_and x xs) apply well_formed_foldr_and; assumption. }
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Γ
⊢i (a and foldr patt_and x xs ---> g) --->
   x ---> a ---> foldr patt_imp g xs
using BasicReasoning
    toMLGoal.
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
well_formed
  ((a and foldr patt_and x xs ---> g) --->
   x ---> a ---> foldr patt_imp g xs)
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Γ Ⱶ
(a and foldr patt_and x xs ---> g) --->
x ---> a ---> foldr patt_imp g xs
using BasicReasoning

    {
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
well_formed
  ((a and foldr patt_and x xs ---> g) --->
   x ---> a ---> foldr patt_imp g xs) wf_auto2. }
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Γ Ⱶ
(a and foldr patt_and x xs ---> g) --->
x ---> a ---> foldr patt_imp g xs
using BasicReasoning

    mlIntro "H0".
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Γ Ⱶ
"H0" ∶ a and foldr patt_and x xs ---> g,
--------------------------------------
x ---> a ---> foldr patt_imp g xs
using BasicReasoning
 mlIntro "H1".
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Γ Ⱶ
"H0" ∶ a and foldr patt_and x xs ---> g,
"H1" ∶ x,
--------------------------------------
a ---> foldr patt_imp g xs
using BasicReasoning
 mlIntro "H2".
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Γ Ⱶ
"H0" ∶ a and foldr patt_and x xs ---> g,
"H1" ∶ x,
"H2" ∶ a,
--------------------------------------
foldr patt_imp g xs
using BasicReasoning

    mlAdd IHxs as "H3".
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Γ Ⱶ
"H3" ∶ (foldr patt_and x xs ---> g) --->
       x ---> foldr patt_imp g xs,
"H0" ∶ a and foldr patt_and x xs ---> g,
"H1" ∶ x,
"H2" ∶ a,
--------------------------------------
foldr patt_imp g xs
using BasicReasoning

    mlAssert ("H4" : ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)).
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
Γ Ⱶ
"H3" ∶ (foldr patt_and x xs ---> g) --->
       x ---> foldr patt_imp g xs,
"H0" ∶ a and foldr patt_and x xs ---> g,
"H1" ∶ x,
"H2" ∶ a,
--------------------------------------
(foldr patt_and x xs ---> g) ---> foldr patt_imp g xs
using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
Γ Ⱶ
"H3" ∶ (foldr patt_and x xs ---> g) --->
       x ---> foldr patt_imp g xs,
"H0" ∶ a and foldr patt_and x xs ---> g,
"H1" ∶ x,
"H2" ∶ a,
"H4" ∶ (foldr patt_and x xs ---> g) --->
       foldr patt_imp g xs,
--------------------------------------
foldr patt_imp g xs
using BasicReasoning

    {
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs) wf_auto2. }
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
Γ Ⱶ
"H3" ∶ (foldr patt_and x xs ---> g) --->
       x ---> foldr patt_imp g xs,
"H0" ∶ a and foldr patt_and x xs ---> g,
"H1" ∶ x,
"H2" ∶ a,
--------------------------------------
(foldr patt_and x xs ---> g) ---> foldr patt_imp g xs
using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
Γ Ⱶ
"H3" ∶ (foldr patt_and x xs ---> g) --->
       x ---> foldr patt_imp g xs,
"H0" ∶ a and foldr patt_and x xs ---> g,
"H1" ∶ x,
"H2" ∶ a,
"H4" ∶ (foldr patt_and x xs ---> g) --->
       foldr patt_imp g xs,
--------------------------------------
foldr patt_imp g xs
using BasicReasoning

    {
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
Γ Ⱶ
"H3" ∶ (foldr patt_and x xs ---> g) --->
       x ---> foldr patt_imp g xs,
"H0" ∶ a and foldr patt_and x xs ---> g,
"H1" ∶ x,
"H2" ∶ a,
--------------------------------------
(foldr patt_and x xs ---> g) ---> foldr patt_imp g xs
using BasicReasoning
 mlIntro "H5".
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
Γ Ⱶ
"H3" ∶ (foldr patt_and x xs ---> g) --->
       x ---> foldr patt_imp g xs,
"H0" ∶ a and foldr patt_and x xs ---> g,
"H1" ∶ x,
"H2" ∶ a,
"H5" ∶ foldr patt_and x xs ---> g,
--------------------------------------
foldr patt_imp g xs
using BasicReasoning

      mlAssert ("H6" : (x ---> foldr patt_imp g xs)).
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
well_formed (x ---> foldr patt_imp g xs)
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
Hwf0: well_formed (x ---> foldr patt_imp g xs)
Γ Ⱶ
"H3" ∶ (foldr patt_and x xs ---> g) --->
       x ---> foldr patt_imp g xs,
"H0" ∶ a and foldr patt_and x xs ---> g,
"H1" ∶ x,
"H2" ∶ a,
"H5" ∶ foldr patt_and x xs ---> g,
--------------------------------------
x ---> foldr patt_imp g xs
using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
Hwf0: well_formed (x ---> foldr patt_imp g xs)
Γ Ⱶ
"H3" ∶ (foldr patt_and x xs ---> g) --->
       x ---> foldr patt_imp g xs,
"H0" ∶ a and foldr patt_and x xs ---> g,
"H1" ∶ x,
"H2" ∶ a,
"H5" ∶ foldr patt_and x xs ---> g,
"H6" ∶ x ---> foldr patt_imp g xs,
--------------------------------------
foldr patt_imp g xs
using BasicReasoning

      {
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
well_formed (x ---> foldr patt_imp g xs) wf_auto2. }
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
Hwf0: well_formed (x ---> foldr patt_imp g xs)
Γ Ⱶ
"H3" ∶ (foldr patt_and x xs ---> g) --->
       x ---> foldr patt_imp g xs,
"H0" ∶ a and foldr patt_and x xs ---> g,
"H1" ∶ x,
"H2" ∶ a,
"H5" ∶ foldr patt_and x xs ---> g,
--------------------------------------
x ---> foldr patt_imp g xs
using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
Hwf0: well_formed (x ---> foldr patt_imp g xs)
Γ Ⱶ
"H3" ∶ (foldr patt_and x xs ---> g) --->
       x ---> foldr patt_imp g xs,
"H0" ∶ a and foldr patt_and x xs ---> g,
"H1" ∶ x,
"H2" ∶ a,
"H5" ∶ foldr patt_and x xs ---> g,
"H6" ∶ x ---> foldr patt_imp g xs,
--------------------------------------
foldr patt_imp g xs
using BasicReasoning

      {
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
Hwf0: well_formed (x ---> foldr patt_imp g xs)
Γ Ⱶ
"H3" ∶ (foldr patt_and x xs ---> g) --->
       x ---> foldr patt_imp g xs,
"H0" ∶ a and foldr patt_and x xs ---> g,
"H1" ∶ x,
"H2" ∶ a,
"H5" ∶ foldr patt_and x xs ---> g,
--------------------------------------
x ---> foldr patt_imp g xs
using BasicReasoning
 mlApply "H3".
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
Hwf0: well_formed (x ---> foldr patt_imp g xs)
Γ Ⱶ
"H3" ∶ (foldr patt_and x xs ---> g) --->
       x ---> foldr patt_imp g xs,
"H0" ∶ a and foldr patt_and x xs ---> g,
"H1" ∶ x,
"H2" ∶ a,
"H5" ∶ foldr patt_and x xs ---> g,
--------------------------------------
foldr patt_and x xs ---> g
using BasicReasoning
 mlExact "H5". }
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
Hwf0: well_formed (x ---> foldr patt_imp g xs)
Γ Ⱶ
"H3" ∶ (foldr patt_and x xs ---> g) --->
       x ---> foldr patt_imp g xs,
"H0" ∶ a and foldr patt_and x xs ---> g,
"H1" ∶ x,
"H2" ∶ a,
"H5" ∶ foldr patt_and x xs ---> g,
"H6" ∶ x ---> foldr patt_imp g xs,
--------------------------------------
foldr patt_imp g xs
using BasicReasoning

      mlClear "H0".
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
Hwf0: well_formed (x ---> foldr patt_imp g xs)
Γ Ⱶ
"H3" ∶ (foldr patt_and x xs ---> g) --->
       x ---> foldr patt_imp g xs,
"H1" ∶ x,
"H2" ∶ a,
"H5" ∶ foldr patt_and x xs ---> g,
"H6" ∶ x ---> foldr patt_imp g xs,
--------------------------------------
foldr patt_imp g xs
using BasicReasoning

      mlApply "H6".
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
Hwf0: well_formed (x ---> foldr patt_imp g xs)
Γ Ⱶ
"H3" ∶ (foldr patt_and x xs ---> g) --->
       x ---> foldr patt_imp g xs,
"H1" ∶ x,
"H2" ∶ a,
"H5" ∶ foldr patt_and x xs ---> g,
"H6" ∶ x ---> foldr patt_imp g xs,
--------------------------------------
x
using BasicReasoning

      mlExact "H1".
    }
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
Γ Ⱶ
"H3" ∶ (foldr patt_and x xs ---> g) --->
       x ---> foldr patt_imp g xs,
"H0" ∶ a and foldr patt_and x xs ---> g,
"H1" ∶ x,
"H2" ∶ a,
"H4" ∶ (foldr patt_and x xs ---> g) --->
       foldr patt_imp g xs,
--------------------------------------
foldr patt_imp g xs
using BasicReasoning

    mlClear "H3".
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
Γ Ⱶ
"H0" ∶ a and foldr patt_and x xs ---> g,
"H1" ∶ x,
"H2" ∶ a,
"H4" ∶ (foldr patt_and x xs ---> g) --->
       foldr patt_imp g xs,
--------------------------------------
foldr patt_imp g xs
using BasicReasoning

    mlApply "H4".
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
Γ Ⱶ
"H0" ∶ a and foldr patt_and x xs ---> g,
"H1" ∶ x,
"H2" ∶ a,
"H4" ∶ (foldr patt_and x xs ---> g) --->
       foldr patt_imp g xs,
--------------------------------------
foldr patt_and x xs ---> g
using BasicReasoning

    mlClear "H4".
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
Γ Ⱶ
"H0" ∶ a and foldr patt_and x xs ---> g,
"H1" ∶ x,
"H2" ∶ a,
--------------------------------------
foldr patt_and x xs ---> g
using BasicReasoning

    mlIntro "H3".
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
Γ Ⱶ
"H0" ∶ a and foldr patt_and x xs ---> g,
"H1" ∶ x,
"H2" ∶ a,
"H3" ∶ foldr patt_and x xs,
--------------------------------------
g
using BasicReasoning

    mlApply "H0".
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
Γ Ⱶ
"H0" ∶ a and foldr patt_and x xs ---> g,
"H1" ∶ x,
"H2" ∶ a,
"H3" ∶ foldr patt_and x xs,
--------------------------------------
a and foldr patt_and x xs
using BasicReasoning

    mlSplitAnd.
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
Γ Ⱶ
"H0" ∶ a and foldr patt_and x xs ---> g,
"H1" ∶ x,
"H2" ∶ a,
"H3" ∶ foldr patt_and x xs,
--------------------------------------
a
using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
Γ Ⱶ
"H0" ∶ a and foldr patt_and x xs ---> g,
"H1" ∶ x,
"H2" ∶ a,
"H3" ∶ foldr patt_and x xs,
--------------------------------------
foldr patt_and x xs
using BasicReasoning

    +
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
Γ Ⱶ
"H0" ∶ a and foldr patt_and x xs ---> g,
"H1" ∶ x,
"H2" ∶ a,
"H3" ∶ foldr patt_and x xs,
--------------------------------------
a
using BasicReasoning
 mlExact "H2".
    +
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (foldr patt_and x xs ---> g) --->
   x ---> foldr patt_imp g xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed
  ((foldr patt_and x xs ---> g) --->
   foldr patt_imp g xs)
Γ Ⱶ
"H0" ∶ a and foldr patt_and x xs ---> g,
"H1" ∶ x,
"H2" ∶ a,
"H3" ∶ foldr patt_and x xs,
--------------------------------------
foldr patt_and x xs
using BasicReasoning
 mlExact "H3".
Defined.

Lemma lhs_and_to_imp_meta {Σ : Signature} Γ (g x : Pattern) (xs : list Pattern) i:
  well_formed g ->
  well_formed x ->
  Pattern.wf xs ->
  Γ ⊢i (foldr patt_and x xs ---> g) using i ->
  Γ ⊢i (foldr patt_imp g (x :: xs)) using i.
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
well_formed g
→ well_formed x
  → Pattern.wf xs
    → Γ ⊢i foldr patt_and x xs ---> g using i
      → Γ ⊢i foldr patt_imp g (x :: xs) using i
Proof.
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
well_formed g
→ well_formed x
  → Pattern.wf xs
    → Γ ⊢i foldr patt_and x xs ---> g using i
      → Γ ⊢i foldr patt_imp g (x :: xs) using i
  intros wfg wfx wfxs H.
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs
H: Γ ⊢i foldr patt_and x xs ---> g using i
Γ ⊢i foldr patt_imp g (x :: xs) using i
  eapply MP.
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs
H: Γ ⊢i foldr patt_and x xs ---> g using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs
H: Γ ⊢i foldr patt_and x xs ---> g using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp g (x :: xs) using i
  2: {
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs
H: Γ ⊢i foldr patt_and x xs ---> g using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp g (x :: xs) using i useBasicReasoning.
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs
H: Γ ⊢i foldr patt_and x xs ---> g using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp g (x :: xs)
using BasicReasoning apply lhs_and_to_imp; assumption. }
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs
H: Γ ⊢i foldr patt_and x xs ---> g using i
Γ ⊢i foldr patt_and x xs ---> g using i
  exact H.
Defined.

Lemma lhs_imp_to_and {Σ : Signature} Γ (g x : Pattern) (xs : list Pattern):
  well_formed g ->
  well_formed x ->
  Pattern.wf xs ->
  Γ ⊢i (foldr patt_imp g (x :: xs)) ---> (foldr patt_and x xs ---> g)
  using BasicReasoning.
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
well_formed g
→ well_formed x
  → Pattern.wf xs
    → Γ
      ⊢i foldr patt_imp g (x :: xs) --->
         foldr patt_and x xs ---> g
      using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
well_formed g
→ well_formed x
  → Pattern.wf xs
    → Γ
      ⊢i foldr patt_imp g (x :: xs) --->
         foldr patt_and x xs ---> g
      using BasicReasoning
  intros wfg wfx wfxs.
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs
Γ
⊢i foldr patt_imp g (x :: xs) --->
   foldr patt_and x xs ---> g using BasicReasoning
  induction xs; simpl.
Σ: Signature
Γ: Theory
g, x: Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf []
Γ ⊢i (x ---> g) ---> x ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs
→ Γ
  ⊢i foldr patt_imp g (x :: xs) --->
     foldr patt_and x xs ---> g
  using BasicReasoning
Γ
⊢i (x ---> a ---> foldr patt_imp g xs) --->
   a and foldr patt_and x xs ---> g
using BasicReasoning
  {
Σ: Signature
Γ: Theory
g, x: Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf []
Γ ⊢i (x ---> g) ---> x ---> g using BasicReasoning
    apply A_impl_A.
Σ: Signature
Γ: Theory
g, x: Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf []
well_formed (x ---> g)
    wf_auto2.
  }
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs
→ Γ
  ⊢i foldr patt_imp g (x :: xs) --->
     foldr patt_and x xs ---> g
  using BasicReasoning
Γ
⊢i (x ---> a ---> foldr patt_imp g xs) --->
   a and foldr patt_and x xs ---> g
using BasicReasoning
  {
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs
→ Γ
  ⊢i foldr patt_imp g (x :: xs) --->
     foldr patt_and x xs ---> g
  using BasicReasoning
Γ
⊢i (x ---> a ---> foldr patt_imp g xs) --->
   a and foldr patt_and x xs ---> g
using BasicReasoning
    pose proof (wfaxs := wfxs).
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs
→ Γ
  ⊢i foldr patt_imp g (x :: xs) --->
     foldr patt_and x xs ---> g
  using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Γ
⊢i (x ---> a ---> foldr patt_imp g xs) --->
   a and foldr patt_and x xs ---> g
using BasicReasoning
    unfold Pattern.wf in wfxs.
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: foldr andb true (map well_formed (a :: xs))
IHxs: Pattern.wf xs
→ Γ
  ⊢i foldr patt_imp g (x :: xs) --->
     foldr patt_and x xs ---> g
  using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Γ
⊢i (x ---> a ---> foldr patt_imp g xs) --->
   a and foldr patt_and x xs ---> g
using BasicReasoning
    simpl in wfxs.
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: well_formed a &&
foldr andb true (map well_formed xs)
IHxs: Pattern.wf xs
→ Γ
  ⊢i foldr patt_imp g (x :: xs) --->
     foldr patt_and x xs ---> g
  using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Γ
⊢i (x ---> a ---> foldr patt_imp g xs) --->
   a and foldr patt_and x xs ---> g
using BasicReasoning
    apply andb_prop in wfxs as [wfa wfxs].
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: foldr andb true (map well_formed xs) = true
IHxs: Pattern.wf xs
→ Γ
  ⊢i foldr patt_imp g (x :: xs) --->
     foldr patt_and x xs ---> g
  using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Γ
⊢i (x ---> a ---> foldr patt_imp g xs) --->
   a and foldr patt_and x xs ---> g
using BasicReasoning
    fold (Pattern.wf xs) in wfxs.
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Pattern.wf xs
→ Γ
  ⊢i foldr patt_imp g (x :: xs) --->
     foldr patt_and x xs ---> g
  using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Γ
⊢i (x ---> a ---> foldr patt_imp g xs) --->
   a and foldr patt_and x xs ---> g
using BasicReasoning
    specialize (IHxs wfxs).
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i foldr patt_imp g (x :: xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Γ
⊢i (x ---> a ---> foldr patt_imp g xs) --->
   a and foldr patt_and x xs ---> g
using BasicReasoning
    simpl in IHxs.
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Γ
⊢i (x ---> a ---> foldr patt_imp g xs) --->
   a and foldr patt_and x xs ---> g
using BasicReasoning
    assert (Hwffa: well_formed (foldr patt_and x xs)).
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
well_formed (foldr patt_and x xs)
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Γ
⊢i (x ---> a ---> foldr patt_imp g xs) --->
   a and foldr patt_and x xs ---> g
using BasicReasoning
    {
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
well_formed (foldr patt_and x xs) apply well_formed_foldr_and; assumption. }
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Γ
⊢i (x ---> a ---> foldr patt_imp g xs) --->
   a and foldr patt_and x xs ---> g
using BasicReasoning
    toMLGoal.
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
well_formed
  ((x ---> a ---> foldr patt_imp g xs) --->
   a and foldr patt_and x xs ---> g)
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Γ Ⱶ
(x ---> a ---> foldr patt_imp g xs) --->
a and foldr patt_and x xs ---> g
using BasicReasoning

    {
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
well_formed
  ((x ---> a ---> foldr patt_imp g xs) --->
   a and foldr patt_and x xs ---> g) wf_auto2. }
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Γ Ⱶ
(x ---> a ---> foldr patt_imp g xs) --->
a and foldr patt_and x xs ---> g
using BasicReasoning

    mlAdd IHxs as "H".
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Γ Ⱶ
"H" ∶ (x ---> foldr patt_imp g xs) --->
      foldr patt_and x xs ---> g,
--------------------------------------
(x ---> a ---> foldr patt_imp g xs) --->
a and foldr patt_and x xs ---> g
using BasicReasoning

    mlIntro "H1".
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Γ Ⱶ
"H" ∶ (x ---> foldr patt_imp g xs) --->
      foldr patt_and x xs ---> g,
"H1" ∶ x ---> a ---> foldr patt_imp g xs,
--------------------------------------
a and foldr patt_and x xs ---> g
using BasicReasoning

    mlIntro "H2".
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Γ Ⱶ
"H" ∶ (x ---> foldr patt_imp g xs) --->
      foldr patt_and x xs ---> g,
"H1" ∶ x ---> a ---> foldr patt_imp g xs,
"H2" ∶ a and foldr patt_and x xs,
--------------------------------------
g
using BasicReasoning

    mlDestructAnd "H2" as "H3" "H4".
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Γ Ⱶ
"H" ∶ (x ---> foldr patt_imp g xs) --->
      foldr patt_and x xs ---> g,
"H1" ∶ x ---> a ---> foldr patt_imp g xs,
"H3" ∶ a,
"H4" ∶ foldr patt_and x xs,
--------------------------------------
g
using BasicReasoning

    mlApplyMeta reorder in "H1".
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Γ Ⱶ
"H" ∶ (x ---> foldr patt_imp g xs) --->
      foldr patt_and x xs ---> g,
"H1" ∶ a ---> x ---> foldr patt_imp g xs,
"H3" ∶ a,
"H4" ∶ foldr patt_and x xs,
--------------------------------------
g
using BasicReasoning

    mlAssert ("H5": (x ---> foldr patt_imp g xs)).
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
well_formed (x ---> foldr patt_imp g xs)
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
Γ Ⱶ
"H" ∶ (x ---> foldr patt_imp g xs) --->
      foldr patt_and x xs ---> g,
"H1" ∶ a ---> x ---> foldr patt_imp g xs,
"H3" ∶ a,
"H4" ∶ foldr patt_and x xs,
--------------------------------------
x ---> foldr patt_imp g xs
using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
Γ Ⱶ
"H" ∶ (x ---> foldr patt_imp g xs) --->
      foldr patt_and x xs ---> g,
"H1" ∶ a ---> x ---> foldr patt_imp g xs,
"H3" ∶ a,
"H4" ∶ foldr patt_and x xs,
"H5" ∶ x ---> foldr patt_imp g xs,
--------------------------------------
g
using BasicReasoning

    {
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
well_formed (x ---> foldr patt_imp g xs) wf_auto2. }
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
Γ Ⱶ
"H" ∶ (x ---> foldr patt_imp g xs) --->
      foldr patt_and x xs ---> g,
"H1" ∶ a ---> x ---> foldr patt_imp g xs,
"H3" ∶ a,
"H4" ∶ foldr patt_and x xs,
--------------------------------------
x ---> foldr patt_imp g xs
using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
Γ Ⱶ
"H" ∶ (x ---> foldr patt_imp g xs) --->
      foldr patt_and x xs ---> g,
"H1" ∶ a ---> x ---> foldr patt_imp g xs,
"H3" ∶ a,
"H4" ∶ foldr patt_and x xs,
"H5" ∶ x ---> foldr patt_imp g xs,
--------------------------------------
g
using BasicReasoning

    {
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
Γ Ⱶ
"H" ∶ (x ---> foldr patt_imp g xs) --->
      foldr patt_and x xs ---> g,
"H1" ∶ a ---> x ---> foldr patt_imp g xs,
"H3" ∶ a,
"H4" ∶ foldr patt_and x xs,
--------------------------------------
x ---> foldr patt_imp g xs
using BasicReasoning

      mlApply "H1".
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
Γ Ⱶ
"H" ∶ (x ---> foldr patt_imp g xs) --->
      foldr patt_and x xs ---> g,
"H1" ∶ a ---> x ---> foldr patt_imp g xs,
"H3" ∶ a,
"H4" ∶ foldr patt_and x xs,
--------------------------------------
a
using BasicReasoning

      mlExact "H3".  
    }
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
Γ Ⱶ
"H" ∶ (x ---> foldr patt_imp g xs) --->
      foldr patt_and x xs ---> g,
"H1" ∶ a ---> x ---> foldr patt_imp g xs,
"H3" ∶ a,
"H4" ∶ foldr patt_and x xs,
"H5" ∶ x ---> foldr patt_imp g xs,
--------------------------------------
g
using BasicReasoning

    mlAssert ("H6" : (foldr patt_and x xs ---> g)).
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
well_formed (foldr patt_and x xs ---> g)
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
Hwf0: well_formed (foldr patt_and x xs ---> g)
Γ Ⱶ
"H" ∶ (x ---> foldr patt_imp g xs) --->
      foldr patt_and x xs ---> g,
"H1" ∶ a ---> x ---> foldr patt_imp g xs,
"H3" ∶ a,
"H4" ∶ foldr patt_and x xs,
"H5" ∶ x ---> foldr patt_imp g xs,
--------------------------------------
foldr patt_and x xs ---> g
using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
Hwf0: well_formed (foldr patt_and x xs ---> g)
Γ Ⱶ
"H" ∶ (x ---> foldr patt_imp g xs) --->
      foldr patt_and x xs ---> g,
"H1" ∶ a ---> x ---> foldr patt_imp g xs,
"H3" ∶ a,
"H4" ∶ foldr patt_and x xs,
"H5" ∶ x ---> foldr patt_imp g xs,
"H6" ∶ foldr patt_and x xs ---> g,
--------------------------------------
g
using BasicReasoning

    {
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
well_formed (foldr patt_and x xs ---> g) wf_auto2. }
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
Hwf0: well_formed (foldr patt_and x xs ---> g)
Γ Ⱶ
"H" ∶ (x ---> foldr patt_imp g xs) --->
      foldr patt_and x xs ---> g,
"H1" ∶ a ---> x ---> foldr patt_imp g xs,
"H3" ∶ a,
"H4" ∶ foldr patt_and x xs,
"H5" ∶ x ---> foldr patt_imp g xs,
--------------------------------------
foldr patt_and x xs ---> g
using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
Hwf0: well_formed (foldr patt_and x xs ---> g)
Γ Ⱶ
"H" ∶ (x ---> foldr patt_imp g xs) --->
      foldr patt_and x xs ---> g,
"H1" ∶ a ---> x ---> foldr patt_imp g xs,
"H3" ∶ a,
"H4" ∶ foldr patt_and x xs,
"H5" ∶ x ---> foldr patt_imp g xs,
"H6" ∶ foldr patt_and x xs ---> g,
--------------------------------------
g
using BasicReasoning

    {
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
Hwf0: well_formed (foldr patt_and x xs ---> g)
Γ Ⱶ
"H" ∶ (x ---> foldr patt_imp g xs) --->
      foldr patt_and x xs ---> g,
"H1" ∶ a ---> x ---> foldr patt_imp g xs,
"H3" ∶ a,
"H4" ∶ foldr patt_and x xs,
"H5" ∶ x ---> foldr patt_imp g xs,
--------------------------------------
foldr patt_and x xs ---> g
using BasicReasoning

      mlApply "H".
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
Hwf0: well_formed (foldr patt_and x xs ---> g)
Γ Ⱶ
"H" ∶ (x ---> foldr patt_imp g xs) --->
      foldr patt_and x xs ---> g,
"H1" ∶ a ---> x ---> foldr patt_imp g xs,
"H3" ∶ a,
"H4" ∶ foldr patt_and x xs,
"H5" ∶ x ---> foldr patt_imp g xs,
--------------------------------------
x ---> foldr patt_imp g xs
using BasicReasoning

      mlExact "H5".
    }
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
Hwf0: well_formed (foldr patt_and x xs ---> g)
Γ Ⱶ
"H" ∶ (x ---> foldr patt_imp g xs) --->
      foldr patt_and x xs ---> g,
"H1" ∶ a ---> x ---> foldr patt_imp g xs,
"H3" ∶ a,
"H4" ∶ foldr patt_and x xs,
"H5" ∶ x ---> foldr patt_imp g xs,
"H6" ∶ foldr patt_and x xs ---> g,
--------------------------------------
g
using BasicReasoning

    mlApply "H6".
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> foldr patt_imp g xs) --->
   foldr patt_and x xs ---> g
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
Hwf0: well_formed (foldr patt_and x xs ---> g)
Γ Ⱶ
"H" ∶ (x ---> foldr patt_imp g xs) --->
      foldr patt_and x xs ---> g,
"H1" ∶ a ---> x ---> foldr patt_imp g xs,
"H3" ∶ a,
"H4" ∶ foldr patt_and x xs,
"H5" ∶ x ---> foldr patt_imp g xs,
"H6" ∶ foldr patt_and x xs ---> g,
--------------------------------------
foldr patt_and x xs
using BasicReasoning

    mlExact "H4".
  }
Defined.


Lemma lhs_imp_to_and_meta {Σ : Signature} Γ (g x : Pattern) (xs : list Pattern) i:
  well_formed g ->
  well_formed x ->
  Pattern.wf xs ->
  Γ ⊢i (foldr patt_imp g (x :: xs)) using i ->
  Γ ⊢i (foldr patt_and x xs ---> g) using i.
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
well_formed g
→ well_formed x
  → Pattern.wf xs
    → Γ ⊢i foldr patt_imp g (x :: xs) using i
      → Γ ⊢i foldr patt_and x xs ---> g using i
Proof.
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
well_formed g
→ well_formed x
  → Pattern.wf xs
    → Γ ⊢i foldr patt_imp g (x :: xs) using i
      → Γ ⊢i foldr patt_and x xs ---> g using i
  intros wfg wfx wfxs H.
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs
H: Γ ⊢i foldr patt_imp g (x :: xs) using i
Γ ⊢i foldr patt_and x xs ---> g using i
  eapply MP.
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs
H: Γ ⊢i foldr patt_imp g (x :: xs) using i
Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs
H: Γ ⊢i foldr patt_imp g (x :: xs) using i
Γ ⊢i ?ϕ₁ ---> foldr patt_and x xs ---> g using i
  2: {
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs
H: Γ ⊢i foldr patt_imp g (x :: xs) using i
Γ ⊢i ?ϕ₁ ---> foldr patt_and x xs ---> g using i useBasicReasoning.
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs
H: Γ ⊢i foldr patt_imp g (x :: xs) using i
Γ ⊢i ?ϕ₁ ---> foldr patt_and x xs ---> g
using BasicReasoning apply lhs_imp_to_and; assumption. }
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs
H: Γ ⊢i foldr patt_imp g (x :: xs) using i
Γ ⊢i foldr patt_imp g (x :: xs) using i
  exact H.
Defined.

Lemma foldr_and_impl_last {Σ : Signature} Γ (x : Pattern) (xs : list Pattern):
  well_formed x ->
  Pattern.wf xs ->
  Γ ⊢i (foldr patt_and x xs ---> x) using BasicReasoning.
Σ: Signature
Γ: Theory
x: Pattern
xs: list Pattern
well_formed x
→ Pattern.wf xs
  → Γ ⊢i foldr patt_and x xs ---> x
    using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
x: Pattern
xs: list Pattern
well_formed x
→ Pattern.wf xs
  → Γ ⊢i foldr patt_and x xs ---> x
    using BasicReasoning
  intros wfx wfxs.
Σ: Signature
Γ: Theory
x: Pattern
xs: list Pattern
wfx: well_formed x
wfxs: Pattern.wf xs
Γ ⊢i foldr patt_and x xs ---> x using BasicReasoning
  induction xs; simpl.
Σ: Signature
Γ: Theory
x: Pattern
wfx: well_formed x
wfxs: Pattern.wf []
Γ ⊢i x ---> x using BasicReasoning
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs
→ Γ ⊢i foldr patt_and x xs ---> x
  using BasicReasoning
Γ ⊢i a and foldr patt_and x xs ---> x
using BasicReasoning
  {
Σ: Signature
Γ: Theory
x: Pattern
wfx: well_formed x
wfxs: Pattern.wf []
Γ ⊢i x ---> x using BasicReasoning
    apply A_impl_A.
Σ: Signature
Γ: Theory
x: Pattern
wfx: well_formed x
wfxs: Pattern.wf []
well_formed x
    exact wfx.
  }
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs
→ Γ ⊢i foldr patt_and x xs ---> x
  using BasicReasoning
Γ ⊢i a and foldr patt_and x xs ---> x
using BasicReasoning
  {
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs
→ Γ ⊢i foldr patt_and x xs ---> x
  using BasicReasoning
Γ ⊢i a and foldr patt_and x xs ---> x
using BasicReasoning
    pose proof (wfaxs := wfxs).
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs
→ Γ ⊢i foldr patt_and x xs ---> x
  using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Γ ⊢i a and foldr patt_and x xs ---> x
using BasicReasoning
    unfold Pattern.wf in wfxs.
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfxs: foldr andb true (map well_formed (a :: xs))
IHxs: Pattern.wf xs
→ Γ ⊢i foldr patt_and x xs ---> x
  using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Γ ⊢i a and foldr patt_and x xs ---> x
using BasicReasoning
    simpl in wfxs.
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfxs: well_formed a &&
foldr andb true (map well_formed xs)
IHxs: Pattern.wf xs
→ Γ ⊢i foldr patt_and x xs ---> x
  using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Γ ⊢i a and foldr patt_and x xs ---> x
using BasicReasoning
    apply andb_prop in wfxs as [wfa wfxs].
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: foldr andb true (map well_formed xs) = true
IHxs: Pattern.wf xs
→ Γ ⊢i foldr patt_and x xs ---> x
  using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Γ ⊢i a and foldr patt_and x xs ---> x
using BasicReasoning
    fold (Pattern.wf xs) in wfxs.
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Pattern.wf xs
→ Γ ⊢i foldr patt_and x xs ---> x
  using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Γ ⊢i a and foldr patt_and x xs ---> x
using BasicReasoning
    specialize (IHxs wfxs).
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i foldr patt_and x xs ---> x
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Γ ⊢i a and foldr patt_and x xs ---> x
using BasicReasoning
    assert (Hwf2: well_formed (foldr patt_and x xs)).
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i foldr patt_and x xs ---> x
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
well_formed (foldr patt_and x xs)
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i foldr patt_and x xs ---> x
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf2: well_formed (foldr patt_and x xs)
Γ ⊢i a and foldr patt_and x xs ---> x
using BasicReasoning
    {
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i foldr patt_and x xs ---> x
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
well_formed (foldr patt_and x xs) apply well_formed_foldr_and; assumption. }
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i foldr patt_and x xs ---> x
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf2: well_formed (foldr patt_and x xs)
Γ ⊢i a and foldr patt_and x xs ---> x
using BasicReasoning
    toMLGoal.
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i foldr patt_and x xs ---> x
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf2: well_formed (foldr patt_and x xs)
well_formed (a and foldr patt_and x xs ---> x)
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i foldr patt_and x xs ---> x
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf2: well_formed (foldr patt_and x xs)
Γ Ⱶ
a and foldr patt_and x xs ---> x
using BasicReasoning

    {
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i foldr patt_and x xs ---> x
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf2: well_formed (foldr patt_and x xs)
well_formed (a and foldr patt_and x xs ---> x) wf_auto2. }
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i foldr patt_and x xs ---> x
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf2: well_formed (foldr patt_and x xs)
Γ Ⱶ
a and foldr patt_and x xs ---> x
using BasicReasoning

    mlAdd IHxs as "IH".
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i foldr patt_and x xs ---> x
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf2: well_formed (foldr patt_and x xs)
Γ Ⱶ
"IH" ∶ foldr patt_and x xs ---> x,
--------------------------------------
a and foldr patt_and x xs ---> x
using BasicReasoning

    mlIntro "H".
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i foldr patt_and x xs ---> x
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf2: well_formed (foldr patt_and x xs)
Γ Ⱶ
"IH" ∶ foldr patt_and x xs ---> x,
"H" ∶ a and foldr patt_and x xs,
--------------------------------------
x
using BasicReasoning

    mlDestructAnd "H" as "Ha" "Hf".
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i foldr patt_and x xs ---> x
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf2: well_formed (foldr patt_and x xs)
Γ Ⱶ
"IH" ∶ foldr patt_and x xs ---> x,
"Ha" ∶ a,
"Hf" ∶ foldr patt_and x xs,
--------------------------------------
x
using BasicReasoning

    mlApply "IH".
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i foldr patt_and x xs ---> x
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf2: well_formed (foldr patt_and x xs)
Γ Ⱶ
"IH" ∶ foldr patt_and x xs ---> x,
"Ha" ∶ a,
"Hf" ∶ foldr patt_and x xs,
--------------------------------------
foldr patt_and x xs
using BasicReasoning

    mlExact "Hf".
  }
Defined.

Lemma foldr_and_weaken_last {Σ : Signature} Γ (x y : Pattern) (xs : list Pattern):
  well_formed x ->
  well_formed y ->
  Pattern.wf xs ->
  Γ ⊢i (x ---> y) ---> (foldr patt_and x xs ---> foldr patt_and y xs) using BasicReasoning.
Σ: Signature
Γ: Theory
x, y: Pattern
xs: list Pattern
well_formed x
→ well_formed y
  → Pattern.wf xs
    → Γ
      ⊢i (x ---> y) --->
         foldr patt_and x xs ---> foldr patt_and y xs
      using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
x, y: Pattern
xs: list Pattern
well_formed x
→ well_formed y
  → Pattern.wf xs
    → Γ
      ⊢i (x ---> y) --->
         foldr patt_and x xs ---> foldr patt_and y xs
      using BasicReasoning
  intros wfx wfy wfxs.
Σ: Signature
Γ: Theory
x, y: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfxs: Pattern.wf xs
Γ
⊢i (x ---> y) --->
   foldr patt_and x xs ---> foldr patt_and y xs
using BasicReasoning
  induction xs; simpl.
Σ: Signature
Γ: Theory
x, y: Pattern
wfx: well_formed x
wfy: well_formed y
wfxs: Pattern.wf []
Γ ⊢i (x ---> y) ---> x ---> y using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs
→ Γ
  ⊢i (x ---> y) --->
     foldr patt_and x xs --->
     foldr patt_and y xs using BasicReasoning
Γ
⊢i (x ---> y) --->
   a and foldr patt_and x xs --->
   a and foldr patt_and y xs using BasicReasoning
  {
Σ: Signature
Γ: Theory
x, y: Pattern
wfx: well_formed x
wfy: well_formed y
wfxs: Pattern.wf []
Γ ⊢i (x ---> y) ---> x ---> y using BasicReasoning
    apply A_impl_A.
Σ: Signature
Γ: Theory
x, y: Pattern
wfx: well_formed x
wfy: well_formed y
wfxs: Pattern.wf []
well_formed (x ---> y)
    wf_auto2.
  }
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs
→ Γ
  ⊢i (x ---> y) --->
     foldr patt_and x xs --->
     foldr patt_and y xs using BasicReasoning
Γ
⊢i (x ---> y) --->
   a and foldr patt_and x xs --->
   a and foldr patt_and y xs using BasicReasoning
  {
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs
→ Γ
  ⊢i (x ---> y) --->
     foldr patt_and x xs --->
     foldr patt_and y xs using BasicReasoning
Γ
⊢i (x ---> y) --->
   a and foldr patt_and x xs --->
   a and foldr patt_and y xs using BasicReasoning
    pose proof (wfaxs := wfxs).
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs
→ Γ
  ⊢i (x ---> y) --->
     foldr patt_and x xs --->
     foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Γ
⊢i (x ---> y) --->
   a and foldr patt_and x xs --->
   a and foldr patt_and y xs using BasicReasoning
    unfold Pattern.wf in wfxs.
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfxs: foldr andb true (map well_formed (a :: xs))
IHxs: Pattern.wf xs
→ Γ
  ⊢i (x ---> y) --->
     foldr patt_and x xs --->
     foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Γ
⊢i (x ---> y) --->
   a and foldr patt_and x xs --->
   a and foldr patt_and y xs using BasicReasoning
    simpl in wfxs.
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfxs: well_formed a &&
foldr andb true (map well_formed xs)
IHxs: Pattern.wf xs
→ Γ
  ⊢i (x ---> y) --->
     foldr patt_and x xs --->
     foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Γ
⊢i (x ---> y) --->
   a and foldr patt_and x xs --->
   a and foldr patt_and y xs using BasicReasoning
    apply andb_prop in wfxs as [wfa wfxs].
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: foldr andb true (map well_formed xs) = true
IHxs: Pattern.wf xs
→ Γ
  ⊢i (x ---> y) --->
     foldr patt_and x xs --->
     foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Γ
⊢i (x ---> y) --->
   a and foldr patt_and x xs --->
   a and foldr patt_and y xs using BasicReasoning
    fold (Pattern.wf xs) in wfxs.
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Pattern.wf xs
→ Γ
  ⊢i (x ---> y) --->
     foldr patt_and x xs --->
     foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Γ
⊢i (x ---> y) --->
   a and foldr patt_and x xs --->
   a and foldr patt_and y xs using BasicReasoning
    assert (Hwf1: well_formed (foldr patt_and x xs)).
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Pattern.wf xs
→ Γ
  ⊢i (x ---> y) --->
     foldr patt_and x xs --->
     foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
well_formed (foldr patt_and x xs)
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Pattern.wf xs
→ Γ
  ⊢i (x ---> y) --->
     foldr patt_and x xs --->
     foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Γ
⊢i (x ---> y) --->
   a and foldr patt_and x xs --->
   a and foldr patt_and y xs using BasicReasoning
    {
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Pattern.wf xs
→ Γ
  ⊢i (x ---> y) --->
     foldr patt_and x xs --->
     foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
well_formed (foldr patt_and x xs) apply well_formed_foldr_and; assumption. }
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Pattern.wf xs
→ Γ
  ⊢i (x ---> y) --->
     foldr patt_and x xs --->
     foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Γ
⊢i (x ---> y) --->
   a and foldr patt_and x xs --->
   a and foldr patt_and y xs using BasicReasoning
    assert (Hwf2: well_formed (foldr patt_and y xs)).
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Pattern.wf xs
→ Γ
  ⊢i (x ---> y) --->
     foldr patt_and x xs --->
     foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
well_formed (foldr patt_and y xs)
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Pattern.wf xs
→ Γ
  ⊢i (x ---> y) --->
     foldr patt_and x xs --->
     foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Γ
⊢i (x ---> y) --->
   a and foldr patt_and x xs --->
   a and foldr patt_and y xs using BasicReasoning
    {
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Pattern.wf xs
→ Γ
  ⊢i (x ---> y) --->
     foldr patt_and x xs --->
     foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
well_formed (foldr patt_and y xs) apply well_formed_foldr_and; assumption. }
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Pattern.wf xs
→ Γ
  ⊢i (x ---> y) --->
     foldr patt_and x xs --->
     foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Γ
⊢i (x ---> y) --->
   a and foldr patt_and x xs --->
   a and foldr patt_and y xs using BasicReasoning
    specialize (IHxs wfxs).
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> y) --->
   foldr patt_and x xs ---> foldr patt_and y xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Γ
⊢i (x ---> y) --->
   a and foldr patt_and x xs --->
   a and foldr patt_and y xs using BasicReasoning
    toMLGoal.
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> y) --->
   foldr patt_and x xs ---> foldr patt_and y xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
well_formed
  ((x ---> y) --->
   a and foldr patt_and x xs --->
   a and foldr patt_and y xs)
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> y) --->
   foldr patt_and x xs ---> foldr patt_and y xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Γ Ⱶ
(x ---> y) --->
a and foldr patt_and x xs --->
a and foldr patt_and y xs
using BasicReasoning

    {
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> y) --->
   foldr patt_and x xs ---> foldr patt_and y xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
well_formed
  ((x ---> y) --->
   a and foldr patt_and x xs --->
   a and foldr patt_and y xs)
      wf_auto2.
    }
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> y) --->
   foldr patt_and x xs ---> foldr patt_and y xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Γ Ⱶ
(x ---> y) --->
a and foldr patt_and x xs --->
a and foldr patt_and y xs
using BasicReasoning

    mlAdd IHxs as "IH".
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> y) --->
   foldr patt_and x xs ---> foldr patt_and y xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Γ Ⱶ
"IH" ∶ (x ---> y) --->
       foldr patt_and x xs ---> foldr patt_and y xs,
--------------------------------------
(x ---> y) --->
a and foldr patt_and x xs --->
a and foldr patt_and y xs
using BasicReasoning

    mlIntro "H1".
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> y) --->
   foldr patt_and x xs ---> foldr patt_and y xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Γ Ⱶ
"IH" ∶ (x ---> y) --->
       foldr patt_and x xs ---> foldr patt_and y xs,
"H1" ∶ x ---> y,
--------------------------------------
a and foldr patt_and x xs --->
a and foldr patt_and y xs
using BasicReasoning

    mlIntro "H2".
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> y) --->
   foldr patt_and x xs ---> foldr patt_and y xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Γ Ⱶ
"IH" ∶ (x ---> y) --->
       foldr patt_and x xs ---> foldr patt_and y xs,
"H1" ∶ x ---> y,
"H2" ∶ a and foldr patt_and x xs,
--------------------------------------
a and foldr patt_and y xs
using BasicReasoning

    mlDestructAnd "H2" as "H3" "H4".
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> y) --->
   foldr patt_and x xs ---> foldr patt_and y xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Γ Ⱶ
"IH" ∶ (x ---> y) --->
       foldr patt_and x xs ---> foldr patt_and y xs,
"H1" ∶ x ---> y,
"H3" ∶ a,
"H4" ∶ foldr patt_and x xs,
--------------------------------------
a and foldr patt_and y xs
using BasicReasoning

    mlSplitAnd;[mlExact "H3"|].
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> y) --->
   foldr patt_and x xs ---> foldr patt_and y xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Γ Ⱶ
"IH" ∶ (x ---> y) --->
       foldr patt_and x xs ---> foldr patt_and y xs,
"H1" ∶ x ---> y,
"H3" ∶ a,
"H4" ∶ foldr patt_and x xs,
--------------------------------------
foldr patt_and y xs
using BasicReasoning

    mlAssert ("IH'": (foldr patt_and x xs ---> foldr patt_and y xs)).
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> y) --->
   foldr patt_and x xs ---> foldr patt_and y xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
well_formed
  (foldr patt_and x xs ---> foldr patt_and y xs)
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> y) --->
   foldr patt_and x xs ---> foldr patt_and y xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Hwf: well_formed
  (foldr patt_and x xs ---> foldr patt_and y xs)
Γ Ⱶ
"IH" ∶ (x ---> y) --->
       foldr patt_and x xs ---> foldr patt_and y xs,
"H1" ∶ x ---> y,
"H3" ∶ a,
"H4" ∶ foldr patt_and x xs,
--------------------------------------
foldr patt_and x xs ---> foldr patt_and y xs
using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> y) --->
   foldr patt_and x xs ---> foldr patt_and y xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Hwf: well_formed
  (foldr patt_and x xs ---> foldr patt_and y xs)
Γ Ⱶ
"IH" ∶ (x ---> y) --->
       foldr patt_and x xs ---> foldr patt_and y xs,
"H1" ∶ x ---> y,
"H3" ∶ a,
"H4" ∶ foldr patt_and x xs,
"IH'" ∶ foldr patt_and x xs ---> foldr patt_and y xs,
--------------------------------------
foldr patt_and y xs
using BasicReasoning

    {
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> y) --->
   foldr patt_and x xs ---> foldr patt_and y xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
well_formed
  (foldr patt_and x xs ---> foldr patt_and y xs)
      wf_auto2.
    }
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> y) --->
   foldr patt_and x xs ---> foldr patt_and y xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Hwf: well_formed
  (foldr patt_and x xs ---> foldr patt_and y xs)
Γ Ⱶ
"IH" ∶ (x ---> y) --->
       foldr patt_and x xs ---> foldr patt_and y xs,
"H1" ∶ x ---> y,
"H3" ∶ a,
"H4" ∶ foldr patt_and x xs,
--------------------------------------
foldr patt_and x xs ---> foldr patt_and y xs
using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> y) --->
   foldr patt_and x xs ---> foldr patt_and y xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Hwf: well_formed
  (foldr patt_and x xs ---> foldr patt_and y xs)
Γ Ⱶ
"IH" ∶ (x ---> y) --->
       foldr patt_and x xs ---> foldr patt_and y xs,
"H1" ∶ x ---> y,
"H3" ∶ a,
"H4" ∶ foldr patt_and x xs,
"IH'" ∶ foldr patt_and x xs ---> foldr patt_and y xs,
--------------------------------------
foldr patt_and y xs
using BasicReasoning

    {
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> y) --->
   foldr patt_and x xs ---> foldr patt_and y xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Hwf: well_formed
  (foldr patt_and x xs ---> foldr patt_and y xs)
Γ Ⱶ
"IH" ∶ (x ---> y) --->
       foldr patt_and x xs ---> foldr patt_and y xs,
"H1" ∶ x ---> y,
"H3" ∶ a,
"H4" ∶ foldr patt_and x xs,
--------------------------------------
foldr patt_and x xs ---> foldr patt_and y xs
using BasicReasoning

      mlApply "IH".
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> y) --->
   foldr patt_and x xs ---> foldr patt_and y xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Hwf: well_formed
  (foldr patt_and x xs ---> foldr patt_and y xs)
Γ Ⱶ
"IH" ∶ (x ---> y) --->
       foldr patt_and x xs ---> foldr patt_and y xs,
"H1" ∶ x ---> y,
"H3" ∶ a,
"H4" ∶ foldr patt_and x xs,
--------------------------------------
x ---> y
using BasicReasoning

      mlExact "H1".
    }
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> y) --->
   foldr patt_and x xs ---> foldr patt_and y xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Hwf: well_formed
  (foldr patt_and x xs ---> foldr patt_and y xs)
Γ Ⱶ
"IH" ∶ (x ---> y) --->
       foldr patt_and x xs ---> foldr patt_and y xs,
"H1" ∶ x ---> y,
"H3" ∶ a,
"H4" ∶ foldr patt_and x xs,
"IH'" ∶ foldr patt_and x xs ---> foldr patt_and y xs,
--------------------------------------
foldr patt_and y xs
using BasicReasoning

    mlApply "IH'".
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ
⊢i (x ---> y) --->
   foldr patt_and x xs ---> foldr patt_and y xs
using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Hwf: well_formed
  (foldr patt_and x xs ---> foldr patt_and y xs)
Γ Ⱶ
"IH" ∶ (x ---> y) --->
       foldr patt_and x xs ---> foldr patt_and y xs,
"H1" ∶ x ---> y,
"H3" ∶ a,
"H4" ∶ foldr patt_and x xs,
"IH'" ∶ foldr patt_and x xs ---> foldr patt_and y xs,
--------------------------------------
foldr patt_and x xs
using BasicReasoning

    mlExact "H4".
  }
Defined.

Lemma foldr_and_weaken_last_meta {Σ : Signature} Γ (x y : Pattern) (xs : list Pattern) i:
  well_formed x ->
  well_formed y ->
  Pattern.wf xs ->
  Γ ⊢i (x ---> y) using i ->
  Γ ⊢i (foldr patt_and x xs ---> foldr patt_and y xs) using i.
Σ: Signature
Γ: Theory
x, y: Pattern
xs: list Pattern
i: ProofInfo
well_formed x
→ well_formed y
  → Pattern.wf xs
    → Γ ⊢i x ---> y using i
      → Γ
        ⊢i foldr patt_and x xs --->
           foldr patt_and y xs using i
Proof.
Σ: Signature
Γ: Theory
x, y: Pattern
xs: list Pattern
i: ProofInfo
well_formed x
→ well_formed y
  → Pattern.wf xs
    → Γ ⊢i x ---> y using i
      → Γ
        ⊢i foldr patt_and x xs --->
           foldr patt_and y xs using i
  intros wfx wfy wfxs H.
Σ: Signature
Γ: Theory
x, y: Pattern
xs: list Pattern
i: ProofInfo
wfx: well_formed x
wfy: well_formed y
wfxs: Pattern.wf xs
H: Γ ⊢i x ---> y using i
Γ ⊢i foldr patt_and x xs ---> foldr patt_and y xs
using i
  eapply MP;[exact H|].
Σ: Signature
Γ: Theory
x, y: Pattern
xs: list Pattern
i: ProofInfo
wfx: well_formed x
wfy: well_formed y
wfxs: Pattern.wf xs
H: Γ ⊢i x ---> y using i
Γ
⊢i (x ---> y) --->
   foldr patt_and x xs ---> foldr patt_and y xs
using i
  useBasicReasoning.
Σ: Signature
Γ: Theory
x, y: Pattern
xs: list Pattern
i: ProofInfo
wfx: well_formed x
wfy: well_formed y
wfxs: Pattern.wf xs
H: Γ ⊢i x ---> y using i
Γ
⊢i (x ---> y) --->
   foldr patt_and x xs ---> foldr patt_and y xs
using BasicReasoning
  apply foldr_and_weaken_last; assumption.
Defined.

Lemma foldr_and_last_rotate {Σ : Signature} Γ (x1 x2 : Pattern) (xs : list Pattern):
  well_formed x1 ->
  well_formed x2 ->
  Pattern.wf xs ->
  Γ ⊢i ((foldr patt_and x2 (xs ++ [x1])) <---> (x2 and (foldr patt_and x1 xs))) using BasicReasoning.
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
well_formed x1
→ well_formed x2
  → Pattern.wf xs
    → Γ
      ⊢i foldr patt_and x2 (xs ++ [x1]) <--->
         x2 and foldr patt_and x1 xs
      using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
well_formed x1
→ well_formed x2
  → Pattern.wf xs
    → Γ
      ⊢i foldr patt_and x2 (xs ++ [x1]) <--->
         x2 and foldr patt_and x1 xs
      using BasicReasoning
  intros wfx1 wfx2 wfxs.
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfxs: Pattern.wf xs
Γ
⊢i foldr patt_and x2 (xs ++ [x1]) <--->
   x2 and foldr patt_and x1 xs using BasicReasoning
  destruct xs; simpl.
Σ: Signature
Γ: Theory
x1, x2: Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfxs: Pattern.wf []
Γ ⊢i x1 and x2 <---> x2 and x1 using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfxs: Pattern.wf (p :: xs)
Γ
⊢i p and foldr patt_and x2 (xs ++ [x1]) <--->
   x2 and (p and foldr patt_and x1 xs)
using BasicReasoning
  {
Σ: Signature
Γ: Theory
x1, x2: Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfxs: Pattern.wf []
Γ ⊢i x1 and x2 <---> x2 and x1 using BasicReasoning
    apply patt_and_comm; assumption.
  }
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfxs: Pattern.wf (p :: xs)
Γ
⊢i p and foldr patt_and x2 (xs ++ [x1]) <--->
   x2 and (p and foldr patt_and x1 xs)
using BasicReasoning
  {
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfxs: Pattern.wf (p :: xs)
Γ
⊢i p and foldr patt_and x2 (xs ++ [x1]) <--->
   x2 and (p and foldr patt_and x1 xs)
using BasicReasoning
    pose proof (wfaxs := wfxs).
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfxs, wfaxs: Pattern.wf (p :: xs)
Γ
⊢i p and foldr patt_and x2 (xs ++ [x1]) <--->
   x2 and (p and foldr patt_and x1 xs)
using BasicReasoning
    unfold Pattern.wf in wfxs.
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfxs: foldr andb true (map well_formed (p :: xs))
wfaxs: Pattern.wf (p :: xs)
Γ
⊢i p and foldr patt_and x2 (xs ++ [x1]) <--->
   x2 and (p and foldr patt_and x1 xs)
using BasicReasoning
    simpl in wfxs.
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfxs: well_formed p &&
foldr andb true (map well_formed xs)
wfaxs: Pattern.wf (p :: xs)
Γ
⊢i p and foldr patt_and x2 (xs ++ [x1]) <--->
   x2 and (p and foldr patt_and x1 xs)
using BasicReasoning
    apply andb_prop in wfxs as [wfa wfxs].
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: foldr andb true (map well_formed xs) = true
wfaxs: Pattern.wf (p :: xs)
Γ
⊢i p and foldr patt_and x2 (xs ++ [x1]) <--->
   x2 and (p and foldr patt_and x1 xs)
using BasicReasoning
    fold (Pattern.wf xs) in wfxs.
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Γ
⊢i p and foldr patt_and x2 (xs ++ [x1]) <--->
   x2 and (p and foldr patt_and x1 xs)
using BasicReasoning

    assert (Hwf1: well_formed (foldr patt_and (x1 and x2) xs)).
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
well_formed (foldr patt_and (x1 and x2) xs)
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Γ
⊢i p and foldr patt_and x2 (xs ++ [x1]) <--->
   x2 and (p and foldr patt_and x1 xs)
using BasicReasoning
    {
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
well_formed (foldr patt_and (x1 and x2) xs) apply well_formed_foldr_and;[wf_auto2|assumption]. }
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Γ
⊢i p and foldr patt_and x2 (xs ++ [x1]) <--->
   x2 and (p and foldr patt_and x1 xs)
using BasicReasoning
    assert (Hwf2: well_formed (foldr patt_and x1 xs)).
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
well_formed (foldr patt_and x1 xs)
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Γ
⊢i p and foldr patt_and x2 (xs ++ [x1]) <--->
   x2 and (p and foldr patt_and x1 xs)
using BasicReasoning
    {
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
well_formed (foldr patt_and x1 xs) apply well_formed_foldr_and; assumption. }
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Γ
⊢i p and foldr patt_and x2 (xs ++ [x1]) <--->
   x2 and (p and foldr patt_and x1 xs)
using BasicReasoning
    assert (Hwf3: well_formed (foldr patt_and x2 xs)).
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
well_formed (foldr patt_and x2 xs)
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ
⊢i p and foldr patt_and x2 (xs ++ [x1]) <--->
   x2 and (p and foldr patt_and x1 xs)
using BasicReasoning
    {
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
well_formed (foldr patt_and x2 xs) apply well_formed_foldr_and; assumption. }
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ
⊢i p and foldr patt_and x2 (xs ++ [x1]) <--->
   x2 and (p and foldr patt_and x1 xs)
using BasicReasoning

    rewrite foldr_app.
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ
⊢i p and foldr patt_and (foldr patt_and x2 [x1]) xs <--->
   x2 and (p and foldr patt_and x1 xs)
using BasicReasoning simpl.
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ
⊢i p and foldr patt_and (x1 and x2) xs <--->
   x2 and (p and foldr patt_and x1 xs)
using BasicReasoning 
    toMLGoal.
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
well_formed
  (p and foldr patt_and (x1 and x2) xs <--->
   x2 and (p and foldr patt_and x1 xs))
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ
p and foldr patt_and (x1 and x2) xs <--->
x2 and (p and foldr patt_and x1 xs)
using BasicReasoning

    {
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
well_formed
  (p and foldr patt_and (x1 and x2) xs <--->
   x2 and (p and foldr patt_and x1 xs)) wf_auto2. }
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ
p and foldr patt_and (x1 and x2) xs <--->
x2 and (p and foldr patt_and x1 xs)
using BasicReasoning

    mlSplitAnd; mlIntro "H".
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ
"H" ∶ p and foldr patt_and (x1 and x2) xs,
--------------------------------------
x2 and (p and foldr patt_and x1 xs)
using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ
"H" ∶ x2 and (p and foldr patt_and x1 xs),
--------------------------------------
p and foldr patt_and (x1 and x2) xs
using BasicReasoning

    {
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ
"H" ∶ p and foldr patt_and (x1 and x2) xs,
--------------------------------------
x2 and (p and foldr patt_and x1 xs)
using BasicReasoning

      mlDestructAnd "H" as "Ha" "Hf".
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ
"Ha" ∶ p,
"Hf" ∶ foldr patt_and (x1 and x2) xs,
--------------------------------------
x2 and (p and foldr patt_and x1 xs)
using BasicReasoning

      repeat mlSplitAnd.
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ
"Ha" ∶ p,
"Hf" ∶ foldr patt_and (x1 and x2) xs,
--------------------------------------
x2
using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ
"Ha" ∶ p,
"Hf" ∶ foldr patt_and (x1 and x2) xs,
--------------------------------------
p
using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ
"Ha" ∶ p,
"Hf" ∶ foldr patt_and (x1 and x2) xs,
--------------------------------------
foldr patt_and x1 xs
using BasicReasoning

      {
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ
"Ha" ∶ p,
"Hf" ∶ foldr patt_and (x1 and x2) xs,
--------------------------------------
x2
using BasicReasoning
 mlApplyMeta foldr_and_impl_last in "Hf".
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ
"Ha" ∶ p,
"Hf" ∶ x1 and x2,
--------------------------------------
x2
using BasicReasoning

        mlDestructAnd "Hf" as "Hx1" "Hx2".
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ
"Ha" ∶ p,
"Hx1" ∶ x1,
"Hx2" ∶ x2,
--------------------------------------
x2
using BasicReasoning

        mlExact "Hx2".
      }
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ
"Ha" ∶ p,
"Hf" ∶ foldr patt_and (x1 and x2) xs,
--------------------------------------
p
using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ
"Ha" ∶ p,
"Hf" ∶ foldr patt_and (x1 and x2) xs,
--------------------------------------
foldr patt_and x1 xs
using BasicReasoning

      {
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ
"Ha" ∶ p,
"Hf" ∶ foldr patt_and (x1 and x2) xs,
--------------------------------------
p
using BasicReasoning
 mlExact "Ha". }
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ
"Ha" ∶ p,
"Hf" ∶ foldr patt_and (x1 and x2) xs,
--------------------------------------
foldr patt_and x1 xs
using BasicReasoning

      {
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ
"Ha" ∶ p,
"Hf" ∶ foldr patt_and (x1 and x2) xs,
--------------------------------------
foldr patt_and x1 xs
using BasicReasoning

        mlApplyMeta foldr_and_weaken_last_meta in "Hf".
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ
"Ha" ∶ p,
"Hf" ∶ foldr patt_and ?y xs,
--------------------------------------
foldr patt_and x1 xs
using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
h: Γ ⊢i x1 and x2 ---> ?y using BasicReasoning
→ Γ Ⱶ
"Ha" ∶ p,
"Hf" ∶ foldr patt_and (x1 and x2) xs,
--------------------------------------
foldr patt_and x1 xs
using BasicReasoning

Γ ⊢i x1 and x2 ---> ?y using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
h: well_formed ?y
→ Γ Ⱶ
"Ha" ∶ p,
"Hf" ∶ foldr patt_and (x1 and x2) xs,
--------------------------------------
foldr patt_and x1 xs
using BasicReasoning

well_formed ?y
        2: {
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
h: Γ ⊢i x1 and x2 ---> ?y using BasicReasoning
→ Γ Ⱶ
"Ha" ∶ p,
"Hf" ∶ foldr patt_and (x1 and x2) xs,
--------------------------------------
foldr patt_and x1 xs
using BasicReasoning

Γ ⊢i x1 and x2 ---> ?y using BasicReasoning apply pf_conj_elim_l; wf_auto2. }
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ
"Ha" ∶ p,
"Hf" ∶ foldr patt_and x1 xs,
--------------------------------------
foldr patt_and x1 xs
using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
h: well_formed x1
→ Γ Ⱶ
"Ha" ∶ p,
"Hf" ∶ foldr patt_and (x1 and x2) xs,
--------------------------------------
foldr patt_and x1 xs
using BasicReasoning

well_formed x1
        2: wf_auto2.
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ
"Ha" ∶ p,
"Hf" ∶ foldr patt_and x1 xs,
--------------------------------------
foldr patt_and x1 xs
using BasicReasoning

        mlExact "Hf".
      }
    }
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ
"H" ∶ x2 and (p and foldr patt_and x1 xs),
--------------------------------------
p and foldr patt_and (x1 and x2) xs
using BasicReasoning

    {
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ
"H" ∶ x2 and (p and foldr patt_and x1 xs),
--------------------------------------
p and foldr patt_and (x1 and x2) xs
using BasicReasoning

      mlDestructAnd "H" as "H1" "H1'".
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ
"H1" ∶ x2,
"H1'" ∶ p and foldr patt_and x1 xs,
--------------------------------------
p and foldr patt_and (x1 and x2) xs
using BasicReasoning

      mlDestructAnd "H1'" as "H2" "H3".
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ
"H1" ∶ x2,
"H2" ∶ p,
"H3" ∶ foldr patt_and x1 xs,
--------------------------------------
p and foldr patt_and (x1 and x2) xs
using BasicReasoning

      mlSplitAnd;[mlExact "H2"|].
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ
"H1" ∶ x2,
"H2" ∶ p,
"H3" ∶ foldr patt_and x1 xs,
--------------------------------------
foldr patt_and (x1 and x2) xs
using BasicReasoning

      mlAssert ("Hf": (x2 and foldr patt_and x1 xs)).
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
well_formed (x2 and foldr patt_and x1 xs)
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Γ Ⱶ
"H1" ∶ x2,
"H2" ∶ p,
"H3" ∶ foldr patt_and x1 xs,
--------------------------------------
x2 and foldr patt_and x1 xs
using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Γ Ⱶ
"H1" ∶ x2,
"H2" ∶ p,
"H3" ∶ foldr patt_and x1 xs,
"Hf" ∶ x2 and foldr patt_and x1 xs,
--------------------------------------
foldr patt_and (x1 and x2) xs
using BasicReasoning

      {
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
well_formed (x2 and foldr patt_and x1 xs) wf_auto2. }
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Γ Ⱶ
"H1" ∶ x2,
"H2" ∶ p,
"H3" ∶ foldr patt_and x1 xs,
--------------------------------------
x2 and foldr patt_and x1 xs
using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Γ Ⱶ
"H1" ∶ x2,
"H2" ∶ p,
"H3" ∶ foldr patt_and x1 xs,
"Hf" ∶ x2 and foldr patt_and x1 xs,
--------------------------------------
foldr patt_and (x1 and x2) xs
using BasicReasoning

      {
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Γ Ⱶ
"H1" ∶ x2,
"H2" ∶ p,
"H3" ∶ foldr patt_and x1 xs,
--------------------------------------
x2 and foldr patt_and x1 xs
using BasicReasoning
 mlSplitAnd;[mlExact "H1"|mlExact "H3"]. }
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Γ Ⱶ
"H1" ∶ x2,
"H2" ∶ p,
"H3" ∶ foldr patt_and x1 xs,
"Hf" ∶ x2 and foldr patt_and x1 xs,
--------------------------------------
foldr patt_and (x1 and x2) xs
using BasicReasoning

      mlAdd (foldr_and_weaken_last Γ x1 (x1 and x2) xs ltac:(wf_auto2) ltac:(wf_auto2) ltac:(wf_auto2))as "Hw".
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Γ Ⱶ
"Hw" ∶ (x1 ---> x1 and x2) --->
       foldr patt_and x1 xs --->
       foldr patt_and (x1 and x2) xs,
"H1" ∶ x2,
"H2" ∶ p,
"H3" ∶ foldr patt_and x1 xs,
"Hf" ∶ x2 and foldr patt_and x1 xs,
--------------------------------------
foldr patt_and (x1 and x2) xs
using BasicReasoning

      mlAssert ("Hw'" : (foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs)).
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
well_formed
  (foldr patt_and x1 xs --->
   foldr patt_and (x1 and x2) xs)
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Hwf0: well_formed
  (foldr patt_and x1 xs --->
   foldr patt_and (x1 and x2) xs)
Γ Ⱶ
"Hw" ∶ (x1 ---> x1 and x2) --->
       foldr patt_and x1 xs --->
       foldr patt_and (x1 and x2) xs,
"H1" ∶ x2,
"H2" ∶ p,
"H3" ∶ foldr patt_and x1 xs,
"Hf" ∶ x2 and foldr patt_and x1 xs,
--------------------------------------
foldr patt_and x1 xs --->
foldr patt_and (x1 and x2) xs
using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Hwf0: well_formed
  (foldr patt_and x1 xs --->
   foldr patt_and (x1 and x2) xs)
Γ Ⱶ
"Hw" ∶ (x1 ---> x1 and x2) --->
       foldr patt_and x1 xs --->
       foldr patt_and (x1 and x2) xs,
"H1" ∶ x2,
"H2" ∶ p,
"H3" ∶ foldr patt_and x1 xs,
"Hf" ∶ x2 and foldr patt_and x1 xs,
"Hw'" ∶ foldr patt_and x1 xs --->
        foldr patt_and (x1 and x2) xs,
--------------------------------------
foldr patt_and (x1 and x2) xs
using BasicReasoning

      {
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
well_formed
  (foldr patt_and x1 xs --->
   foldr patt_and (x1 and x2) xs) wf_auto2. }
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Hwf0: well_formed
  (foldr patt_and x1 xs --->
   foldr patt_and (x1 and x2) xs)
Γ Ⱶ
"Hw" ∶ (x1 ---> x1 and x2) --->
       foldr patt_and x1 xs --->
       foldr patt_and (x1 and x2) xs,
"H1" ∶ x2,
"H2" ∶ p,
"H3" ∶ foldr patt_and x1 xs,
"Hf" ∶ x2 and foldr patt_and x1 xs,
--------------------------------------
foldr patt_and x1 xs --->
foldr patt_and (x1 and x2) xs
using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Hwf0: well_formed
  (foldr patt_and x1 xs --->
   foldr patt_and (x1 and x2) xs)
Γ Ⱶ
"Hw" ∶ (x1 ---> x1 and x2) --->
       foldr patt_and x1 xs --->
       foldr patt_and (x1 and x2) xs,
"H1" ∶ x2,
"H2" ∶ p,
"H3" ∶ foldr patt_and x1 xs,
"Hf" ∶ x2 and foldr patt_and x1 xs,
"Hw'" ∶ foldr patt_and x1 xs --->
        foldr patt_and (x1 and x2) xs,
--------------------------------------
foldr patt_and (x1 and x2) xs
using BasicReasoning

      {
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Hwf0: well_formed
  (foldr patt_and x1 xs --->
   foldr patt_and (x1 and x2) xs)
Γ Ⱶ
"Hw" ∶ (x1 ---> x1 and x2) --->
       foldr patt_and x1 xs --->
       foldr patt_and (x1 and x2) xs,
"H1" ∶ x2,
"H2" ∶ p,
"H3" ∶ foldr patt_and x1 xs,
"Hf" ∶ x2 and foldr patt_and x1 xs,
--------------------------------------
foldr patt_and x1 xs --->
foldr patt_and (x1 and x2) xs
using BasicReasoning

        mlApply "Hw".
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Hwf0: well_formed
  (foldr patt_and x1 xs --->
   foldr patt_and (x1 and x2) xs)
Γ Ⱶ
"Hw" ∶ (x1 ---> x1 and x2) --->
       foldr patt_and x1 xs --->
       foldr patt_and (x1 and x2) xs,
"H1" ∶ x2,
"H2" ∶ p,
"H3" ∶ foldr patt_and x1 xs,
"Hf" ∶ x2 and foldr patt_and x1 xs,
--------------------------------------
x1 ---> x1 and x2
using BasicReasoning

        mlIntro "Hx1".
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Hwf0: well_formed
  (foldr patt_and x1 xs --->
   foldr patt_and (x1 and x2) xs)
Γ Ⱶ
"Hw" ∶ (x1 ---> x1 and x2) --->
       foldr patt_and x1 xs --->
       foldr patt_and (x1 and x2) xs,
"H1" ∶ x2,
"H2" ∶ p,
"H3" ∶ foldr patt_and x1 xs,
"Hf" ∶ x2 and foldr patt_and x1 xs,
"Hx1" ∶ x1,
--------------------------------------
x1 and x2
using BasicReasoning

        mlSplitAnd;[mlExact "Hx1"|mlExact "H1"].
      }
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Hwf0: well_formed
  (foldr patt_and x1 xs --->
   foldr patt_and (x1 and x2) xs)
Γ Ⱶ
"Hw" ∶ (x1 ---> x1 and x2) --->
       foldr patt_and x1 xs --->
       foldr patt_and (x1 and x2) xs,
"H1" ∶ x2,
"H2" ∶ p,
"H3" ∶ foldr patt_and x1 xs,
"Hf" ∶ x2 and foldr patt_and x1 xs,
"Hw'" ∶ foldr patt_and x1 xs --->
        foldr patt_and (x1 and x2) xs,
--------------------------------------
foldr patt_and (x1 and x2) xs
using BasicReasoning

      mlApply "Hw'".
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Hwf0: well_formed
  (foldr patt_and x1 xs --->
   foldr patt_and (x1 and x2) xs)
Γ Ⱶ
"Hw" ∶ (x1 ---> x1 and x2) --->
       foldr patt_and x1 xs --->
       foldr patt_and (x1 and x2) xs,
"H1" ∶ x2,
"H2" ∶ p,
"H3" ∶ foldr patt_and x1 xs,
"Hf" ∶ x2 and foldr patt_and x1 xs,
"Hw'" ∶ foldr patt_and x1 xs --->
        foldr patt_and (x1 and x2) xs,
--------------------------------------
foldr patt_and x1 xs
using BasicReasoning

      mlExact "H3".
    }
  }
Defined.

Lemma foldr_and_last_rotate_1 {Σ : Signature} Γ (x1 x2 : Pattern) (xs : list Pattern):
  well_formed x1 ->
  well_formed x2 ->
  Pattern.wf xs ->
  Γ ⊢i ((foldr patt_and x2 (xs ++ [x1])) ---> (x2 and (foldr patt_and x1 xs))) using BasicReasoning.
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
well_formed x1
→ well_formed x2
  → Pattern.wf xs
    → Γ
      ⊢i foldr patt_and x2 (xs ++ [x1]) --->
         x2 and foldr patt_and x1 xs
      using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
well_formed x1
→ well_formed x2
  → Pattern.wf xs
    → Γ
      ⊢i foldr patt_and x2 (xs ++ [x1]) --->
         x2 and foldr patt_and x1 xs
      using BasicReasoning
  intros.
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
Γ
⊢i foldr patt_and x2 (xs ++ [x1]) --->
   x2 and foldr patt_and x1 xs using BasicReasoning
  assert (well_formed (foldr patt_and (x1 and x2) xs)).
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
well_formed (foldr patt_and (x1 and x2) xs)
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
Γ
⊢i foldr patt_and x2 (xs ++ [x1]) --->
   x2 and foldr patt_and x1 xs using BasicReasoning
  {
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
well_formed (foldr patt_and (x1 and x2) xs) apply well_formed_foldr_and; wf_auto2. }
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
Γ
⊢i foldr patt_and x2 (xs ++ [x1]) --->
   x2 and foldr patt_and x1 xs using BasicReasoning
  assert (well_formed (foldr patt_and x1 xs)).
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
well_formed (foldr patt_and x1 xs)
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
Γ
⊢i foldr patt_and x2 (xs ++ [x1]) --->
   x2 and foldr patt_and x1 xs using BasicReasoning
  {
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
well_formed (foldr patt_and x1 xs) apply well_formed_foldr_and; wf_auto2. }
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
Γ
⊢i foldr patt_and x2 (xs ++ [x1]) --->
   x2 and foldr patt_and x1 xs using BasicReasoning
  eapply pf_iff_proj1.
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
well_formed (foldr patt_and x2 (xs ++ [x1]))
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
well_formed (x2 and foldr patt_and x1 xs)
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
Γ
⊢i foldr patt_and x2 (xs ++ [x1]) <--->
   x2 and foldr patt_and x1 xs using BasicReasoning
  3: {
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
Γ
⊢i foldr patt_and x2 (xs ++ [x1]) <--->
   x2 and foldr patt_and x1 xs using BasicReasoning apply foldr_and_last_rotate; assumption. }
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
well_formed (foldr patt_and x2 (xs ++ [x1]))
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
well_formed (x2 and foldr patt_and x1 xs)
  {
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
well_formed (foldr patt_and x2 (xs ++ [x1]))
    rewrite foldr_app.
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
well_formed
  (foldr patt_and (foldr patt_and x2 [x1]) xs) simpl.
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
well_formed (foldr patt_and (x1 and x2) xs) wf_auto2.
  }
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
well_formed (x2 and foldr patt_and x1 xs)
  apply well_formed_and; wf_auto2.
Defined.

Lemma foldr_and_last_rotate_2 {Σ : Signature} Γ (x1 x2 : Pattern) (xs : list Pattern):
  well_formed x1 ->
  well_formed x2 ->
  Pattern.wf xs ->
  Γ ⊢i ((x2 and (foldr patt_and x1 xs)) ---> ((foldr patt_and x2 (xs ++ [x1])))) using BasicReasoning.
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
well_formed x1
→ well_formed x2
  → Pattern.wf xs
    → Γ
      ⊢i x2 and foldr patt_and x1 xs --->
         foldr patt_and x2 (xs ++ [x1])
      using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
well_formed x1
→ well_formed x2
  → Pattern.wf xs
    → Γ
      ⊢i x2 and foldr patt_and x1 xs --->
         foldr patt_and x2 (xs ++ [x1])
      using BasicReasoning
  intros.
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
Γ
⊢i x2 and foldr patt_and x1 xs --->
   foldr patt_and x2 (xs ++ [x1]) using BasicReasoning
  assert (well_formed (foldr patt_and (x1 and x2) xs)).
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
well_formed (foldr patt_and (x1 and x2) xs)
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
Γ
⊢i x2 and foldr patt_and x1 xs --->
   foldr patt_and x2 (xs ++ [x1]) using BasicReasoning
  {
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
well_formed (foldr patt_and (x1 and x2) xs) apply well_formed_foldr_and; wf_auto2. }
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
Γ
⊢i x2 and foldr patt_and x1 xs --->
   foldr patt_and x2 (xs ++ [x1]) using BasicReasoning
  assert (well_formed (foldr patt_and x1 xs)).
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
well_formed (foldr patt_and x1 xs)
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
Γ
⊢i x2 and foldr patt_and x1 xs --->
   foldr patt_and x2 (xs ++ [x1]) using BasicReasoning
  {
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
well_formed (foldr patt_and x1 xs) apply well_formed_foldr_and; wf_auto2. }
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
Γ
⊢i x2 and foldr patt_and x1 xs --->
   foldr patt_and x2 (xs ++ [x1]) using BasicReasoning
  eapply pf_iff_proj2.
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
well_formed (foldr patt_and x2 (xs ++ [x1]))
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
well_formed (x2 and foldr patt_and x1 xs)
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
Γ
⊢i foldr patt_and x2 (xs ++ [x1]) <--->
   x2 and foldr patt_and x1 xs using BasicReasoning
  3: {
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
Γ
⊢i foldr patt_and x2 (xs ++ [x1]) <--->
   x2 and foldr patt_and x1 xs using BasicReasoning apply foldr_and_last_rotate; assumption. }
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
well_formed (foldr patt_and x2 (xs ++ [x1]))
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
well_formed (x2 and foldr patt_and x1 xs)
  {
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
well_formed (foldr patt_and x2 (xs ++ [x1]))
    rewrite foldr_app.
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
well_formed
  (foldr patt_and (foldr patt_and x2 [x1]) xs) simpl.
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
well_formed (foldr patt_and (x1 and x2) xs) wf_auto2.
  }
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
well_formed (x2 and foldr patt_and x1 xs)
  apply well_formed_and; wf_auto2.
Defined.

#[local]
Ltac tryExact l idx :=
  match l with
    | nil => idtac
    | (?a :: ?m) => try mlExactn idx; tryExact m (idx + 1)
  end.

#[global]
Ltac mlAssumption :=
  _ensureProofMode; (* maybe useless? *)
  match goal with
    | [ |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm ?Ctx ?l ?g ?i) ] 
      =>
        tryExact l 0
  end.




Lemma impl_eq_or {Σ : Signature} Γ a b:
  well_formed a ->
  well_formed b ->
  Γ ⊢i ( (a ---> b) <---> ((! a) or b) )
  using BasicReasoning.
Σ: Signature
Γ: Theory
a, b: Pattern
well_formed a
→ well_formed b
  → Γ ⊢i (a ---> b) <---> ! a or b
    using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
a, b: Pattern
well_formed a
→ well_formed b
  → Γ ⊢i (a ---> b) <---> ! a or b
    using BasicReasoning
  intros wfa wfb.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ ⊢i (a ---> b) <---> ! a or b using BasicReasoning
  toMLGoal.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
well_formed ((a ---> b) <---> ! a or b)
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
(a ---> b) <---> ! a or b
using BasicReasoning

  {
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
well_formed ((a ---> b) <---> ! a or b) wf_auto2. }
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
(a ---> b) <---> ! a or b
using BasicReasoning

  mlIntro "H0".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H0" ∶ ! ((a ---> b) ---> ! a or b)
       or ! (! a or b ---> a ---> b),
--------------------------------------
⊥
using BasicReasoning

  mlDestructOr "H0" as "H1" "H2".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H1" ∶ ! ((a ---> b) ---> ! a or b),
--------------------------------------
⊥
using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ ! (! a or b ---> a ---> b),
--------------------------------------
⊥
using BasicReasoning

  -
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H1" ∶ ! ((a ---> b) ---> ! a or b),
--------------------------------------
⊥
using BasicReasoning
 mlApply "H1".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H1" ∶ ((a ---> b) ---> ! a or b) ---> ⊥,
--------------------------------------
(a ---> b) ---> ! a or b
using BasicReasoning
 mlIntro "H2".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H1" ∶ ((a ---> b) ---> ! a or b) ---> ⊥,
"H2" ∶ a ---> b,
--------------------------------------
! a or b
using BasicReasoning
 mlClear "H1".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ a ---> b,
--------------------------------------
! a or b
using BasicReasoning
 mlIntro "H1".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ a ---> b,
"H1" ∶ ! ! a,
--------------------------------------
b
using BasicReasoning

    mlApplyMeta not_not_elim in "H1".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ a ---> b,
"H1" ∶ a,
--------------------------------------
b
using BasicReasoning

    mlApply "H2".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ a ---> b,
"H1" ∶ a,
--------------------------------------
a
using BasicReasoning
 mlAssumption.
  -
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ ! (! a or b ---> a ---> b),
--------------------------------------
⊥
using BasicReasoning
 mlApply "H2".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ (! a or b ---> a ---> b) ---> ⊥,
--------------------------------------
! a or b ---> a ---> b
using BasicReasoning
 mlIntro "H0".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ (! a or b ---> a ---> b) ---> ⊥,
"H0" ∶ ! a or b,
--------------------------------------
a ---> b
using BasicReasoning
 mlClear "H2".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H0" ∶ ! a or b,
--------------------------------------
a ---> b
using BasicReasoning
 mlIntro "H1".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H0" ∶ ! a or b,
"H1" ∶ a,
--------------------------------------
b
using BasicReasoning

    mlDestructOr "H0" as "H2" "H3".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ ! a,
"H1" ∶ a,
--------------------------------------
b
using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H3" ∶ b,
"H1" ∶ a,
--------------------------------------
b
using BasicReasoning

    +
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ ! a,
"H1" ∶ a,
--------------------------------------
b
using BasicReasoning
 mlExFalso.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ ! a,
"H1" ∶ a,
--------------------------------------
⊥
using BasicReasoning

      mlApply "H2".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ a ---> ⊥,
"H1" ∶ a,
--------------------------------------
a
using BasicReasoning
 mlAssumption.
    +
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H3" ∶ b,
"H1" ∶ a,
--------------------------------------
b
using BasicReasoning
 mlAssumption.
Defined.


Lemma nimpl_eq_and {Σ : Signature} Γ a b:
  well_formed a ->
  well_formed b ->
  Γ ⊢i ( ! (a ---> b) <---> (a and !b) )
  using BasicReasoning.
Σ: Signature
Γ: Theory
a, b: Pattern
well_formed a
→ well_formed b
  → Γ ⊢i ! (a ---> b) <---> a and ! b
    using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
a, b: Pattern
well_formed a
→ well_formed b
  → Γ ⊢i ! (a ---> b) <---> a and ! b
    using BasicReasoning
  intros wfa wfb.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ ⊢i ! (a ---> b) <---> a and ! b using BasicReasoning
  toMLGoal.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
well_formed (! (a ---> b) <---> a and ! b)
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
! (a ---> b) <---> a and ! b
using BasicReasoning

  {
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
well_formed (! (a ---> b) <---> a and ! b) wf_auto2. }
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
! (a ---> b) <---> a and ! b
using BasicReasoning

  mlIntro "H0".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H0" ∶ ! (! (a ---> b) ---> a and ! b)
       or ! (a and ! b ---> ! (a ---> b)),
--------------------------------------
⊥
using BasicReasoning

  mlDestructOr "H0" as "H1" "H2".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H1" ∶ ! (! (a ---> b) ---> a and ! b),
--------------------------------------
⊥
using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ ! (a and ! b ---> ! (a ---> b)),
--------------------------------------
⊥
using BasicReasoning

  -
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H1" ∶ ! (! (a ---> b) ---> a and ! b),
--------------------------------------
⊥
using BasicReasoning
 mlApply "H1".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H1" ∶ (! (a ---> b) ---> a and ! b) ---> ⊥,
--------------------------------------
! (a ---> b) ---> a and ! b
using BasicReasoning
 mlIntro "H0".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H1" ∶ (! (a ---> b) ---> a and ! b) ---> ⊥,
"H0" ∶ ! (a ---> b),
--------------------------------------
a and ! b
using BasicReasoning

    unfold patt_and.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H1" ∶ (! (a ---> b) ---> ! (! a or ! ! b)) ---> ⊥,
"H0" ∶ ! (a ---> b),
--------------------------------------
! (! a or ! ! b)
using BasicReasoning
 mlIntro "H2".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H1" ∶ (! (a ---> b) ---> ! (! a or ! ! b)) ---> ⊥,
"H0" ∶ ! (a ---> b),
"H2" ∶ ! a or ! ! b,
--------------------------------------
⊥
using BasicReasoning

    mlApply "H0".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H1" ∶ (! (a ---> b) ---> ! (! a or ! ! b)) ---> ⊥,
"H0" ∶ (a ---> b) ---> ⊥,
"H2" ∶ ! a or ! ! b,
--------------------------------------
a ---> b
using BasicReasoning
 mlIntro "H3".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H1" ∶ (! (a ---> b) ---> ! (! a or ! ! b)) ---> ⊥,
"H0" ∶ (a ---> b) ---> ⊥,
"H2" ∶ ! a or ! ! b,
"H3" ∶ a,
--------------------------------------
b
using BasicReasoning

    mlDestructOr "H2" as "H4" "H5".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H1" ∶ (! (a ---> b) ---> ! (! a or ! ! b)) ---> ⊥,
"H0" ∶ (a ---> b) ---> ⊥,
"H4" ∶ ! a,
"H3" ∶ a,
--------------------------------------
b
using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H1" ∶ (! (a ---> b) ---> ! (! a or ! ! b)) ---> ⊥,
"H0" ∶ (a ---> b) ---> ⊥,
"H5" ∶ ! ! b,
"H3" ∶ a,
--------------------------------------
b
using BasicReasoning

    +
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H1" ∶ (! (a ---> b) ---> ! (! a or ! ! b)) ---> ⊥,
"H0" ∶ (a ---> b) ---> ⊥,
"H4" ∶ ! a,
"H3" ∶ a,
--------------------------------------
b
using BasicReasoning
 mlExFalso.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H1" ∶ (! (a ---> b) ---> ! (! a or ! ! b)) ---> ⊥,
"H0" ∶ (a ---> b) ---> ⊥,
"H4" ∶ ! a,
"H3" ∶ a,
--------------------------------------
⊥
using BasicReasoning

      mlApply "H4".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H1" ∶ (! (a ---> b) ---> ! (! a or ! ! b)) ---> ⊥,
"H0" ∶ (a ---> b) ---> ⊥,
"H4" ∶ a ---> ⊥,
"H3" ∶ a,
--------------------------------------
a
using BasicReasoning
 mlAssumption.
    +
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H1" ∶ (! (a ---> b) ---> ! (! a or ! ! b)) ---> ⊥,
"H0" ∶ (a ---> b) ---> ⊥,
"H5" ∶ ! ! b,
"H3" ∶ a,
--------------------------------------
b
using BasicReasoning
 mlApplyMeta not_not_elim in "H5".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H1" ∶ (! (a ---> b) ---> ! (! a or ! ! b)) ---> ⊥,
"H0" ∶ (a ---> b) ---> ⊥,
"H5" ∶ b,
"H3" ∶ a,
--------------------------------------
b
using BasicReasoning

      mlAssumption.
  -
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ ! (a and ! b ---> ! (a ---> b)),
--------------------------------------
⊥
using BasicReasoning
 mlApply "H2".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ (a and ! b ---> ! (a ---> b)) ---> ⊥,
--------------------------------------
a and ! b ---> ! (a ---> b)
using BasicReasoning
 mlIntro "H0".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ (a and ! b ---> ! (a ---> b)) ---> ⊥,
"H0" ∶ a and ! b,
--------------------------------------
! (a ---> b)
using BasicReasoning
 mlIntro "H1".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ (a and ! b ---> ! (a ---> b)) ---> ⊥,
"H0" ∶ a and ! b,
"H1" ∶ a ---> b,
--------------------------------------
⊥
using BasicReasoning

    mlDestructAnd "H0" as "H3" "H4".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ (a and ! b ---> ! (a ---> b)) ---> ⊥,
"H3" ∶ a,
"H4" ∶ ! b,
"H1" ∶ a ---> b,
--------------------------------------
⊥
using BasicReasoning
 mlApply "H4".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ (a and ! b ---> ! (a ---> b)) ---> ⊥,
"H3" ∶ a,
"H4" ∶ b ---> ⊥,
"H1" ∶ a ---> b,
--------------------------------------
b
using BasicReasoning
 mlApply "H1".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ (a and ! b ---> ! (a ---> b)) ---> ⊥,
"H3" ∶ a,
"H4" ∶ b ---> ⊥,
"H1" ∶ a ---> b,
--------------------------------------
a
using BasicReasoning

    mlAssumption.
Defined.


Lemma deMorgan_nand {Σ : Signature} Γ a b:
    well_formed a ->
    well_formed b ->
    Γ ⊢i ( !(a and b) <---> (!a or !b) )
    using BasicReasoning.
Σ: Signature
Γ: Theory
a, b: Pattern
well_formed a
→ well_formed b
  → Γ ⊢i ! (a and b) <---> ! a or ! b
    using BasicReasoning
  Proof.
Σ: Signature
Γ: Theory
a, b: Pattern
well_formed a
→ well_formed b
  → Γ ⊢i ! (a and b) <---> ! a or ! b
    using BasicReasoning
    intros wfa wfb.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ ⊢i ! (a and b) <---> ! a or ! b using BasicReasoning
    toMLGoal.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
well_formed (! (a and b) <---> ! a or ! b)
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
! (a and b) <---> ! a or ! b
using BasicReasoning

    {
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
well_formed (! (a and b) <---> ! a or ! b) wf_auto2. }
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
! (a and b) <---> ! a or ! b
using BasicReasoning

    mlIntro "H0".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H0" ∶ ! (! (a and b) ---> ! a or ! b)
       or ! (! a or ! b ---> ! (a and b)),
--------------------------------------
⊥
using BasicReasoning

    mlDestructOr "H0" as "H1" "H2".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H1" ∶ ! (! (a and b) ---> ! a or ! b),
--------------------------------------
⊥
using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ ! (! a or ! b ---> ! (a and b)),
--------------------------------------
⊥
using BasicReasoning

    -
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H1" ∶ ! (! (a and b) ---> ! a or ! b),
--------------------------------------
⊥
using BasicReasoning
 mlRevertLast.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
! (! (a and b) ---> ! a or ! b) ---> ⊥
using BasicReasoning

      mlApplyMeta not_not_intro.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
! (a and b) ---> ! a or ! b
using BasicReasoning
 mlIntro "H0".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H0" ∶ ! (a and b),
--------------------------------------
! a or ! b
using BasicReasoning

      mlApplyMeta not_not_elim in "H0".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H0" ∶ ! a or ! b,
--------------------------------------
! a or ! b
using BasicReasoning

      mlAssumption.
    -
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ ! (! a or ! b ---> ! (a and b)),
--------------------------------------
⊥
using BasicReasoning
 mlRevertLast.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
! (! a or ! b ---> ! (a and b)) ---> ⊥
using BasicReasoning

      mlApplyMeta not_not_intro.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
! a or ! b ---> ! (a and b)
using BasicReasoning
 mlIntro "H0".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H0" ∶ ! a or ! b,
--------------------------------------
! (a and b)
using BasicReasoning

      mlApplyMeta not_not_intro.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H0" ∶ ! a or ! b,
--------------------------------------
! a or ! b
using BasicReasoning

      mlAssumption.
Defined.

Lemma deMorgan_nor {Σ : Signature} Γ a b:
    well_formed a ->
    well_formed b ->
    Γ ⊢i ( !(a or b) <---> (!a and !b))
    using BasicReasoning.
Σ: Signature
Γ: Theory
a, b: Pattern
well_formed a
→ well_formed b
  → Γ ⊢i ! (a or b) <---> ! a and ! b
    using BasicReasoning
  Proof.
Σ: Signature
Γ: Theory
a, b: Pattern
well_formed a
→ well_formed b
  → Γ ⊢i ! (a or b) <---> ! a and ! b
    using BasicReasoning
    intros wfa wfb.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ ⊢i ! (a or b) <---> ! a and ! b using BasicReasoning
    toMLGoal.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
well_formed (! (a or b) <---> ! a and ! b)
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
! (a or b) <---> ! a and ! b
using BasicReasoning

    {
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
well_formed (! (a or b) <---> ! a and ! b) wf_auto2. }
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
! (a or b) <---> ! a and ! b
using BasicReasoning

    mlIntro "H0".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H0" ∶ ! (! (a or b) ---> ! a and ! b)
       or ! (! a and ! b ---> ! (a or b)),
--------------------------------------
⊥
using BasicReasoning

    mlDestructOr "H0" as "H1" "H2".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H1" ∶ ! (! (a or b) ---> ! a and ! b),
--------------------------------------
⊥
using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ ! (! a and ! b ---> ! (a or b)),
--------------------------------------
⊥
using BasicReasoning

    -
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H1" ∶ ! (! (a or b) ---> ! a and ! b),
--------------------------------------
⊥
using BasicReasoning
 mlRevertLast.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
! (! (a or b) ---> ! a and ! b) ---> ⊥
using BasicReasoning

      mlApplyMeta not_not_intro.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
! (a or b) ---> ! a and ! b
using BasicReasoning

      mlIntro "H0".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H0" ∶ ! (a or b),
--------------------------------------
! a and ! b
using BasicReasoning
 mlIntro "H1".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H0" ∶ ! (a or b),
"H1" ∶ ! ! a or ! ! b,
--------------------------------------
⊥
using BasicReasoning

      mlApply "H0".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H0" ∶ a or b ---> ⊥,
"H1" ∶ ! ! a or ! ! b,
--------------------------------------
a or b
using BasicReasoning

      mlDestructOr "H1" as "H2" "H3".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H0" ∶ a or b ---> ⊥,
"H2" ∶ ! ! a,
--------------------------------------
a or b
using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H0" ∶ a or b ---> ⊥,
"H3" ∶ ! ! b,
--------------------------------------
a or b
using BasicReasoning

      +
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H0" ∶ a or b ---> ⊥,
"H2" ∶ ! ! a,
--------------------------------------
a or b
using BasicReasoning
 mlApplyMeta not_not_elim in "H2".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H0" ∶ a or b ---> ⊥,
"H2" ∶ a,
--------------------------------------
a or b
using BasicReasoning

        mlLeft.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H0" ∶ a or b ---> ⊥,
"H2" ∶ a,
--------------------------------------
a
using BasicReasoning
 mlAssumption.
      +
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H0" ∶ a or b ---> ⊥,
"H3" ∶ ! ! b,
--------------------------------------
a or b
using BasicReasoning
 mlApplyMeta not_not_elim in "H3".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H0" ∶ a or b ---> ⊥,
"H3" ∶ b,
--------------------------------------
a or b
using BasicReasoning

        mlRight.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H0" ∶ a or b ---> ⊥,
"H3" ∶ b,
--------------------------------------
b
using BasicReasoning
 mlAssumption.
    -
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ ! (! a and ! b ---> ! (a or b)),
--------------------------------------
⊥
using BasicReasoning
 mlRevertLast.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
! (! a and ! b ---> ! (a or b)) ---> ⊥
using BasicReasoning

      mlApplyMeta not_not_intro.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
! a and ! b ---> ! (a or b)
using BasicReasoning

      mlIntro "H0".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H0" ∶ ! a and ! b,
--------------------------------------
! (a or b)
using BasicReasoning
 mlIntro "H1".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H0" ∶ ! a and ! b,
"H1" ∶ a or b,
--------------------------------------
⊥
using BasicReasoning

      mlDestructAnd "H0" as "H2" "H3".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ ! a,
"H3" ∶ ! b,
"H1" ∶ a or b,
--------------------------------------
⊥
using BasicReasoning

      mlDestructOr "H1" as "H4" "H5".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ ! a,
"H3" ∶ ! b,
"H4" ∶ a,
--------------------------------------
⊥
using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ ! a,
"H3" ∶ ! b,
"H5" ∶ b,
--------------------------------------
⊥
using BasicReasoning

      +
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ ! a,
"H3" ∶ ! b,
"H4" ∶ a,
--------------------------------------
⊥
using BasicReasoning
 mlApply "H2".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ a ---> ⊥,
"H3" ∶ ! b,
"H4" ∶ a,
--------------------------------------
a
using BasicReasoning
 mlAssumption.
      +
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ ! a,
"H3" ∶ ! b,
"H5" ∶ b,
--------------------------------------
⊥
using BasicReasoning
 mlApply "H3".
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ
"H2" ∶ ! a,
"H3" ∶ b ---> ⊥,
"H5" ∶ b,
--------------------------------------
b
using BasicReasoning
 mlAssumption.
  Defined.

Lemma not_not_eq {Σ : Signature} (Γ : Theory) (a : Pattern) :
  well_formed a ->
  Γ ⊢i (!(!a) <---> a)
  using BasicReasoning.
Σ: Signature
Γ: Theory
a: Pattern
well_formed a
→ Γ ⊢i ! ! a <---> a using BasicReasoning
Proof.
Σ: Signature
Γ: Theory
a: Pattern
well_formed a
→ Γ ⊢i ! ! a <---> a using BasicReasoning
  intros wfa.
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ ⊢i ! ! a <---> a using BasicReasoning
  toMLGoal.
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
well_formed (! ! a <---> a)
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ
! ! a <---> a
using BasicReasoning

  {
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
well_formed (! ! a <---> a) wf_auto2. }
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ
! ! a <---> a
using BasicReasoning

  mlIntro "H0".
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ
"H0" ∶ ! (! ! a ---> a) or ! (a ---> ! ! a),
--------------------------------------
⊥
using BasicReasoning

  mlDestructOr "H0" as "H1" "H2".
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ
"H1" ∶ ! (! ! a ---> a),
--------------------------------------
⊥
using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ
"H2" ∶ ! (a ---> ! ! a),
--------------------------------------
⊥
using BasicReasoning

  -
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ
"H1" ∶ ! (! ! a ---> a),
--------------------------------------
⊥
using BasicReasoning
 mlApply "H1".
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ
"H1" ∶ (! ! a ---> a) ---> ⊥,
--------------------------------------
! ! a ---> a
using BasicReasoning
 mlIntro "H0".
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ
"H1" ∶ (! ! a ---> a) ---> ⊥,
"H0" ∶ ! ! a,
--------------------------------------
a
using BasicReasoning

    mlApplyMeta not_not_elim in "H0".
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ
"H1" ∶ (! ! a ---> a) ---> ⊥,
"H0" ∶ a,
--------------------------------------
a
using BasicReasoning

    mlAssumption.
  -
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ
"H2" ∶ ! (a ---> ! ! a),
--------------------------------------
⊥
using BasicReasoning
 unfold patt_not.
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ
"H2" ∶ (a ---> (a ---> ⊥) ---> ⊥) ---> ⊥,
--------------------------------------
⊥
using BasicReasoning
 mlApply "H2".
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ
"H2" ∶ (a ---> (a ---> ⊥) ---> ⊥) ---> ⊥,
--------------------------------------
a ---> (a ---> ⊥) ---> ⊥
using BasicReasoning
 mlIntro "H0".
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ
"H2" ∶ (a ---> (a ---> ⊥) ---> ⊥) ---> ⊥,
"H0" ∶ a,
--------------------------------------
(a ---> ⊥) ---> ⊥
using BasicReasoning
 mlIntro "H1".
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ
"H2" ∶ (a ---> (a ---> ⊥) ---> ⊥) ---> ⊥,
"H0" ∶ a,
"H1" ∶ a ---> ⊥,
--------------------------------------
⊥
using BasicReasoning

    mlApply "H1".
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ
"H2" ∶ (a ---> (a ---> ⊥) ---> ⊥) ---> ⊥,
"H0" ∶ a,
"H1" ∶ a ---> ⊥,
--------------------------------------
a
using BasicReasoning
 mlAssumption.
Defined.


Lemma and_singleton {Σ : Signature} : forall Γ p,
  well_formed p -> Γ ⊢i (p and p) <---> p using BasicReasoning.
Σ: Signature
∀ (Γ : Theory) (p : Pattern),
  well_formed p
  → Γ ⊢i p and p <---> p using BasicReasoning
Proof.
Σ: Signature
∀ (Γ : Theory) (p : Pattern),
  well_formed p
  → Γ ⊢i p and p <---> p using BasicReasoning
  intros Γ p WFp.
Σ: Signature
Γ: Theory
p: Pattern
WFp: well_formed p
Γ ⊢i p and p <---> p using BasicReasoning
  toMLGoal.
Σ: Signature
Γ: Theory
p: Pattern
WFp: well_formed p
well_formed (p and p <---> p)
Σ: Signature
Γ: Theory
p: Pattern
WFp: well_formed p
Γ Ⱶ
p and p <---> p
using BasicReasoning
 wf_auto2.
Σ: Signature
Γ: Theory
p: Pattern
WFp: well_formed p
Γ Ⱶ
p and p <---> p
using BasicReasoning

  mlSplitAnd; mlIntro "H".
Σ: Signature
Γ: Theory
p: Pattern
WFp: well_formed p
Γ Ⱶ
"H" ∶ p and p,
--------------------------------------
p
using BasicReasoning
Σ: Signature
Γ: Theory
p: Pattern
WFp: well_formed p
Γ Ⱶ
"H" ∶ p,
--------------------------------------
p and p
using BasicReasoning

  *
Σ: Signature
Γ: Theory
p: Pattern
WFp: well_formed p
Γ Ⱶ
"H" ∶ p and p,
--------------------------------------
p
using BasicReasoning
 mlDestructAnd "H".
Σ: Signature
Γ: Theory
p: Pattern
WFp: well_formed p
Γ Ⱶ
"0" ∶ p,
"1" ∶ p,
--------------------------------------
p
using BasicReasoning
 mlAssumption.
  *
Σ: Signature
Γ: Theory
p: Pattern
WFp: well_formed p
Γ Ⱶ
"H" ∶ p,
--------------------------------------
p and p
using BasicReasoning
 mlSplitAnd; mlAssumption.
Defined.

Lemma bott_and {Σ : Signature} Γ ϕ :
  well_formed ϕ ->
  Γ ⊢ ⊥ and ϕ <---> ⊥.
Σ: Signature
Γ: Theory
ϕ: Pattern
well_formed ϕ → Γ ⊢ ⊥ and ϕ <---> ⊥
Proof.
Σ: Signature
Γ: Theory
ϕ: Pattern
well_formed ϕ → Γ ⊢ ⊥ and ϕ <---> ⊥
  intro wfϕ.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ ⊢ ⊥ and ϕ <---> ⊥
  toMLGoal.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
well_formed (⊥ and ϕ <---> ⊥)
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
 ⊥ and ϕ <---> ⊥

  {
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
well_formed (⊥ and ϕ <---> ⊥) wf_auto2. }
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
 ⊥ and ϕ <---> ⊥

  mlSplitAnd.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
 ⊥ and ϕ ---> ⊥
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
 ⊥ ---> ⊥ and ϕ

  +
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
 ⊥ and ϕ ---> ⊥
 mlIntro "H".
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H" ∶ ⊥ and ϕ,
--------------------------------------
⊥
 mlDestructAnd "H" as "B" "P".
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"B" ∶ ⊥,
"P" ∶ ϕ,
--------------------------------------
⊥
 mlExact "B".
  +
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
 ⊥ ---> ⊥ and ϕ
 mlIntro "H".
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H" ∶ ⊥,
--------------------------------------
⊥ and ϕ
 mlExFalso.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H" ∶ ⊥,
--------------------------------------
⊥
 mlExact "H".
Defined.

Lemma top_and {Σ : Signature} Γ ϕ :
  well_formed ϕ ->
  Γ ⊢ Top and ϕ <---> ϕ.
Σ: Signature
Γ: Theory
ϕ: Pattern
well_formed ϕ → Γ ⊢ Top and ϕ <---> ϕ
Proof.
Σ: Signature
Γ: Theory
ϕ: Pattern
well_formed ϕ → Γ ⊢ Top and ϕ <---> ϕ
  intro wfϕ.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ ⊢ Top and ϕ <---> ϕ
  toMLGoal.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
well_formed (Top and ϕ <---> ϕ)
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
 Top and ϕ <---> ϕ

  {
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
well_formed (Top and ϕ <---> ϕ) wf_auto2. }
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
 Top and ϕ <---> ϕ

  mlSplitAnd.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
 Top and ϕ ---> ϕ
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
 ϕ ---> Top and ϕ

  +
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
 Top and ϕ ---> ϕ
 mlIntro "H".
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H" ∶ Top and ϕ,
--------------------------------------
ϕ
 mlDestructAnd "H" as "T" "P".
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"T" ∶ Top,
"P" ∶ ϕ,
--------------------------------------
ϕ
 mlExact "P".
  +
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
 ϕ ---> Top and ϕ
 mlIntro "H".
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H" ∶ ϕ,
--------------------------------------
Top and ϕ

    mlSplitAnd.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H" ∶ ϕ,
--------------------------------------
Top
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H" ∶ ϕ,
--------------------------------------
ϕ

    *
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H" ∶ ϕ,
--------------------------------------
Top
 mlClear "H".
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
 Top
 fromMLGoal.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ ⊢i Top using AnyReasoning aapply top_holds.
    *
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ
"H" ∶ ϕ,
--------------------------------------
ϕ
 mlExact "H".
Defined.

Lemma MLGoal_ExactMeta {Σ:Signature} : forall Γ l g i,
  Γ ⊢i g using i ->
  mkMLGoal Σ Γ l g i.
Σ: Signature
∀ (Γ : Theory) (l : hypotheses) (g : Pattern) (i : ProofInfo),
  Γ ⊢i g using i
  → Γ Ⱶ
  l--------------------------------------
  g
  using i
  
Proof.
Σ: Signature
∀ (Γ : Theory) (l : hypotheses) (g : Pattern) (i : ProofInfo),
  Γ ⊢i g using i
  → Γ Ⱶ
  l--------------------------------------
  g
  using i
  
  intros Γ l g i pf wfG wfl.
Σ: Signature
Γ: Theory
l: hypotheses
g: Pattern
i: ProofInfo
pf: Γ ⊢i g using i
wfG: well_formed
(mlConclusion (Γ Ⱶ
l--------------------------------------
g
using i
))
wfl: Pattern.wf
(patterns_of
(mlHypotheses (Γ Ⱶ
l--------------------------------------
g
using i
)))
mlTheory
  (Γ Ⱶ
   l--------------------------------------
   g
   using i
   )
⊢i foldr patt_imp
     (mlConclusion
        (Γ Ⱶ
         l--------------------------------------
         g
         using i
         ))
     (patterns_of
        (mlHypotheses
           (Γ Ⱶ
            l--------------------------------------
            g
            using i
            )))
using mlInfo
        (Γ Ⱶ
         l--------------------------------------
         g
         using i
         )
  unfold of_MLGoal.
Σ: Signature
Γ: Theory
l: hypotheses
g: Pattern
i: ProofInfo
pf: Γ ⊢i g using i
wfG: well_formed
(mlConclusion (Γ Ⱶ
l--------------------------------------
g
using i
))
wfl: Pattern.wf
(patterns_of
(mlHypotheses (Γ Ⱶ
l--------------------------------------
g
using i
)))
mlTheory
  (Γ Ⱶ
   l--------------------------------------
   g
   using i
   )
⊢i foldr patt_imp
     (mlConclusion
        (Γ Ⱶ
         l--------------------------------------
         g
         using i
         ))
     (patterns_of
        (mlHypotheses
           (Γ Ⱶ
            l--------------------------------------
            g
            using i
            )))
using mlInfo
        (Γ Ⱶ
         l--------------------------------------
         g
         using i
         ) simpl in *.
Σ: Signature
Γ: Theory
l: hypotheses
g: Pattern
i: ProofInfo
pf: Γ ⊢i g using i
wfG: well_formed g
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp g (patterns_of l) using i
  induction l; simpl; auto.
Σ: Signature
Γ: Theory
a: named_hypothesis
l: list named_hypothesis
g: Pattern
i: ProofInfo
pf: Γ ⊢i g using i
wfG: well_formed g
wfl: Pattern.wf (patterns_of (a :: l))
IHl: Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
Γ ⊢i nh_patt a ---> foldr patt_imp g (patterns_of l)
using i
  simpl in wfl.
Σ: Signature
Γ: Theory
a: named_hypothesis
l: list named_hypothesis
g: Pattern
i: ProofInfo
pf: Γ ⊢i g using i
wfG: well_formed g
wfl: Pattern.wf (nh_patt a :: patterns_of l)
IHl: Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
Γ ⊢i nh_patt a ---> foldr patt_imp g (patterns_of l)
using i apply wf_tail' in wfl as wfl'.
Σ: Signature
Γ: Theory
a: named_hypothesis
l: list named_hypothesis
g: Pattern
i: ProofInfo
pf: Γ ⊢i g using i
wfG: well_formed g
wfl: Pattern.wf (nh_patt a :: patterns_of l)
IHl: Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
wfl': Pattern.wf (patterns_of l) = true
Γ ⊢i nh_patt a ---> foldr patt_imp g (patterns_of l)
using i
  cbn in wfl.
Σ: Signature
Γ: Theory
a: named_hypothesis
l: list named_hypothesis
g: Pattern
i: ProofInfo
pf: Γ ⊢i g using i
wfG: well_formed g
wfl: well_formed (nh_patt a) && foldr andb true (map well_formed (patterns_of l))
IHl: Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
wfl': Pattern.wf (patterns_of l) = true
Γ ⊢i nh_patt a ---> foldr patt_imp g (patterns_of l)
using i apply andb_true_iff in wfl as [wfl _].
Σ: Signature
Γ: Theory
a: named_hypothesis
l: list named_hypothesis
g: Pattern
i: ProofInfo
pf: Γ ⊢i g using i
wfG: well_formed g
wfl: well_formed (nh_patt a) = true
IHl: Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
wfl': Pattern.wf (patterns_of l) = true
Γ ⊢i nh_patt a ---> foldr patt_imp g (patterns_of l)
using i
  apply prf_conclusion; try solve [wf_auto2].
Σ: Signature
Γ: Theory
a: named_hypothesis
l: list named_hypothesis
g: Pattern
i: ProofInfo
pf: Γ ⊢i g using i
wfG: well_formed g
wfl: well_formed (nh_patt a) = true
IHl: Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
wfl': Pattern.wf (patterns_of l) = true
Γ ⊢i foldr patt_imp g (patterns_of l) using i
  auto with nocore.
Defined.

Tactic Notation "mlExactMeta" uconstr(t) :=
  _ensureProofMode;
  apply (@MLGoal_ExactMeta _ _ _ _ _ t).

Goal forall (Σ : Signature) Γ, Γ ⊢i Top using BasicReasoning.
∀ (Σ : Signature) (Γ : Theory),
  Γ ⊢i Top using BasicReasoning
Proof.
∀ (Σ : Signature) (Γ : Theory),
  Γ ⊢i Top using BasicReasoning
  intros.
Σ: Signature
Γ: Theory
Γ ⊢i Top using BasicReasoning toMLGoal.
Σ: Signature
Γ: Theory
well_formed Top
Σ: Signature
Γ: Theory
Γ Ⱶ
Top
using BasicReasoning
 wf_auto2.
Σ: Signature
Γ: Theory
Γ Ⱶ
Top
using BasicReasoning

  mlExactMeta (top_holds Γ).
Defined.

Local Example exfalso_test {Σ : Signature} p Γ i :
  well_formed p ->
  Γ ⊢i p and ! p ---> Top using i.
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
well_formed p → Γ ⊢i p and ! p ---> Top using i
Proof.
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
well_formed p → Γ ⊢i p and ! p ---> Top using i
  intro WF.
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p
Γ ⊢i p and ! p ---> Top using i toMLGoal.
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p
well_formed (p and ! p ---> Top)
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p
Γ Ⱶ
p and ! p ---> Top
using i

  {
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p
well_formed (p and ! p ---> Top) wf_auto2. }
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p
Γ Ⱶ
p and ! p ---> Top
using i

  mlIntro "H".
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p
Γ Ⱶ
"H" ∶ p and ! p,
--------------------------------------
Top
using i

  mlDestructAnd "H" as "H0" "H1".
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p
Γ Ⱶ
"H0" ∶ p,
"H1" ∶ ! p,
--------------------------------------
Top
using i

  mlExFalso.
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p
Γ Ⱶ
"H0" ∶ p,
"H1" ∶ ! p,
--------------------------------------
⊥
using i

  mlApply "H1".
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p
Γ Ⱶ
"H0" ∶ p,
"H1" ∶ p ---> ⊥,
--------------------------------------
p
using i

  mlExact "H0".
Defined.

Local Example destruct_bot_test {Σ : Signature} p Γ i :
  well_formed p ->
  Γ ⊢i ⊥ ---> Top using i.
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
well_formed p → Γ ⊢i ⊥ ---> Top using i
Proof.
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
well_formed p → Γ ⊢i ⊥ ---> Top using i
  intro WF.
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p
Γ ⊢i ⊥ ---> Top using i toMLGoal.
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p
well_formed (⊥ ---> Top)
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p
Γ Ⱶ
⊥ ---> Top
using i

  {
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p
well_formed (⊥ ---> Top) wf_auto2. }
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p
Γ Ⱶ
⊥ ---> Top
using i

  mlIntro "H".
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p
Γ Ⱶ
"H" ∶ ⊥,
--------------------------------------
Top
using i

  mlDestructBot "H".
Defined.

(**********************************************************************************)




(* This is an example and belongs to the end of this file.
   Its only purpose is only to show as many tactics as possible.\
 *)
 Example ex_and_of_equiv_is_equiv_2 {Σ : Signature} Γ p q p' q' i:
   well_formed p ->
   well_formed q ->
   well_formed p' ->
   well_formed q' ->
   Γ ⊢i (p <---> p') using i ->
   Γ ⊢i (q <---> q') using i ->
   Γ ⊢i ((p and q) <---> (p' and q')) using i.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
well_formed p
→ well_formed q
  → well_formed p'
    → well_formed q'
      → Γ ⊢i p <---> p' using i
        → Γ ⊢i q <---> q' using i
          → Γ ⊢i p and q <---> p' and q' using i
Proof.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
well_formed p
→ well_formed q
  → well_formed p'
    → well_formed q'
      → Γ ⊢i p <---> p' using i
        → Γ ⊢i q <---> q' using i
          → Γ ⊢i p and q <---> p' and q' using i
 intros wfp wfq wfp' wfq' pep' qeq'.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
Γ ⊢i p and q <---> p' and q' using i
 pose proof (pip' := pep').
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p <---> p' using i
Γ ⊢i p and q <---> p' and q' using i apply pf_conj_elim_l_meta in pip'; auto.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
Γ ⊢i p and q <---> p' and q' using i
 pose proof (p'ip := pep').
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p <---> p' using i
Γ ⊢i p and q <---> p' and q' using i apply pf_conj_elim_r_meta in p'ip; auto.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
Γ ⊢i p and q <---> p' and q' using i
 pose proof (qiq' := qeq').
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q <---> q' using i
Γ ⊢i p and q <---> p' and q' using i apply pf_conj_elim_l_meta in qiq'; auto.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
Γ ⊢i p and q <---> p' and q' using i
 pose proof (q'iq := qeq').
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q <---> q' using i
Γ ⊢i p and q <---> p' and q' using i apply pf_conj_elim_r_meta in q'iq; auto.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ ⊢i p and q <---> p' and q' using i

 toMLGoal.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
well_formed (p and q <---> p' and q')
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
p and q <---> p' and q'
using i

 {
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
well_formed (p and q <---> p' and q') wf_auto2. }
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
p and q <---> p' and q'
using i

 unfold patt_iff.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
(p and q ---> p' and q') and (p' and q' ---> p and q)
using i

 mlSplitAnd.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
p and q ---> p' and q'
using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
p' and q' ---> p and q
using i

 -
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
p and q ---> p' and q'
using i
 mlIntro "H0".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ p and q,
--------------------------------------
p' and q'
using i

   mlDestructAnd "H0" as "H1" "H2".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ p,
"H2" ∶ q,
--------------------------------------
p' and q'
using i

   mlSplitAnd.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ p,
"H2" ∶ q,
--------------------------------------
p'
using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ p,
"H2" ∶ q,
--------------------------------------
q'
using i

   +
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ p,
"H2" ∶ q,
--------------------------------------
p'
using i
 mlApplyMeta pip'.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ p,
"H2" ∶ q,
--------------------------------------
p
using i

     mlExactn 0.
   +
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ p,
"H2" ∶ q,
--------------------------------------
q'
using i
 mlApplyMeta qiq' in "H2".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ p,
"H2" ∶ q',
--------------------------------------
q'
using i

     mlExact "H2".
 -
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
p' and q' ---> p and q
using i
 mlIntro "H0".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ p' and q',
--------------------------------------
p and q
using i

   unfold patt_and at 2.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ p' and q',
--------------------------------------
! (! p or ! q)
using i

   unfold patt_not at 1.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ p' and q',
--------------------------------------
! p or ! q ---> ⊥
using i

   mlIntro "H1".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ p' and q',
"H1" ∶ ! p or ! q,
--------------------------------------
⊥
using i

   mlDestructOr "H1" as "H2" "H3".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ p' and q',
"H2" ∶ ! p,
--------------------------------------
⊥
using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ p' and q',
"H3" ∶ ! q,
--------------------------------------
⊥
using i

   +
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ p' and q',
"H2" ∶ ! p,
--------------------------------------
⊥
using i
 mlDestructAnd "H0" as "H3" "H4".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H3" ∶ p',
"H4" ∶ q',
"H2" ∶ ! p,
--------------------------------------
⊥
using i

     unfold patt_not.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H3" ∶ p',
"H4" ∶ q',
"H2" ∶ p ---> ⊥,
--------------------------------------
⊥
using i

     mlApply "H2".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H3" ∶ p',
"H4" ∶ q',
"H2" ∶ p ---> ⊥,
--------------------------------------
p
using i

     mlClear "H2".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H3" ∶ p',
"H4" ∶ q',
--------------------------------------
p
using i

     mlClear "H4".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H3" ∶ p',
--------------------------------------
p
using i

     fromMLGoal.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ ⊢i p' ---> p using i
     exact p'ip.
   +
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ p' and q',
"H3" ∶ ! q,
--------------------------------------
⊥
using i
 mlAdd q'iq as "H1".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ q' ---> q,
"H0" ∶ p' and q',
"H3" ∶ ! q,
--------------------------------------
⊥
using i

     mlDestructAnd "H0" as "H2" "H4".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ q' ---> q,
"H2" ∶ p',
"H4" ∶ q',
"H3" ∶ ! q,
--------------------------------------
⊥
using i

     mlAssert ("Hq" : q).
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
well_formed q
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Hwf: well_formed q
Γ Ⱶ
"H1" ∶ q' ---> q,
"H2" ∶ p',
"H4" ∶ q',
"H3" ∶ ! q,
--------------------------------------
q
using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Hwf: well_formed q
Γ Ⱶ
"H1" ∶ q' ---> q,
"H2" ∶ p',
"H4" ∶ q',
"H3" ∶ ! q,
"Hq" ∶ q,
--------------------------------------
⊥
using i

     {
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
well_formed q wf_auto2. }
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Hwf: well_formed q
Γ Ⱶ
"H1" ∶ q' ---> q,
"H2" ∶ p',
"H4" ∶ q',
"H3" ∶ ! q,
--------------------------------------
q
using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Hwf: well_formed q
Γ Ⱶ
"H1" ∶ q' ---> q,
"H2" ∶ p',
"H4" ∶ q',
"H3" ∶ ! q,
"Hq" ∶ q,
--------------------------------------
⊥
using i

     {
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Hwf: well_formed q
Γ Ⱶ
"H1" ∶ q' ---> q,
"H2" ∶ p',
"H4" ∶ q',
"H3" ∶ ! q,
--------------------------------------
q
using i
 mlApply "H1".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Hwf: well_formed q
Γ Ⱶ
"H1" ∶ q' ---> q,
"H2" ∶ p',
"H4" ∶ q',
"H3" ∶ ! q,
--------------------------------------
q'
using i
 mlExact "H4". }
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Hwf: well_formed q
Γ Ⱶ
"H1" ∶ q' ---> q,
"H2" ∶ p',
"H4" ∶ q',
"H3" ∶ ! q,
"Hq" ∶ q,
--------------------------------------
⊥
using i

     unfold patt_not at 1.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Hwf: well_formed q
Γ Ⱶ
"H1" ∶ q' ---> q,
"H2" ∶ p',
"H4" ∶ q',
"H3" ∶ q ---> ⊥,
"Hq" ∶ q,
--------------------------------------
⊥
using i

     mlApply "H3".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Hwf: well_formed q
Γ Ⱶ
"H1" ∶ q' ---> q,
"H2" ∶ p',
"H4" ∶ q',
"H3" ∶ q ---> ⊥,
"Hq" ∶ q,
--------------------------------------
q
using i

     mlAssumption.
Defined.


#[local]
  Example ex_or_of_equiv_is_equiv_2 {Σ : Signature} Γ p q p' q' i:
    well_formed p ->
    well_formed q ->
    well_formed p' ->
    well_formed q' ->
    Γ ⊢i (p <---> p') using i ->
    Γ ⊢i (q <---> q') using i ->
    Γ ⊢i ((p or q) <---> (p' or q')) using i.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
well_formed p
→ well_formed q
  → well_formed p'
    → well_formed q'
      → Γ ⊢i p <---> p' using i
        → Γ ⊢i q <---> q' using i
          → Γ ⊢i p or q <---> p' or q' using i
  Proof.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
well_formed p
→ well_formed q
  → well_formed p'
    → well_formed q'
      → Γ ⊢i p <---> p' using i
        → Γ ⊢i q <---> q' using i
          → Γ ⊢i p or q <---> p' or q' using i
    intros wfp wfq wfp' wfq' pep' qeq'.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
Γ ⊢i p or q <---> p' or q' using i

    pose proof (pip' := pep').
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p <---> p' using i
Γ ⊢i p or q <---> p' or q' using i apply pf_conj_elim_l_meta in pip'; auto.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
Γ ⊢i p or q <---> p' or q' using i
    pose proof (p'ip := pep').
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p <---> p' using i
Γ ⊢i p or q <---> p' or q' using i apply pf_conj_elim_r_meta in p'ip; auto.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
Γ ⊢i p or q <---> p' or q' using i
    pose proof (qiq' := qeq').
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q <---> q' using i
Γ ⊢i p or q <---> p' or q' using i apply pf_conj_elim_l_meta in qiq'; auto.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
Γ ⊢i p or q <---> p' or q' using i
    pose proof (q'iq := qeq').
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q <---> q' using i
Γ ⊢i p or q <---> p' or q' using i apply pf_conj_elim_r_meta in q'iq; auto.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ ⊢i p or q <---> p' or q' using i

    toMLGoal.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
well_formed (p or q <---> p' or q')
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
p or q <---> p' or q'
using i

    {
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
well_formed (p or q <---> p' or q') wf_auto2. }
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
p or q <---> p' or q'
using i

    unfold patt_iff.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
(p or q ---> p' or q') and (p' or q' ---> p or q)
using i

    mlSplitAnd.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
p or q ---> p' or q'
using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
p' or q' ---> p or q
using i

    -
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
p or q ---> p' or q'
using i
 mlIntro "H0".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ p or q,
--------------------------------------
p' or q'
using i

      mlDestructOr "H0" as "H1" "H2".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ p,
--------------------------------------
p' or q'
using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H2" ∶ q,
--------------------------------------
p' or q'
using i

      mlLeft.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ p,
--------------------------------------
p'
using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H2" ∶ q,
--------------------------------------
p' or q'
using i

      +
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ p,
--------------------------------------
p'
using i
 mlApplyMeta pip'.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ p,
--------------------------------------
p
using i

        mlExact "H1".
      +
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H2" ∶ q,
--------------------------------------
p' or q'
using i
 mlRight.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H2" ∶ q,
--------------------------------------
q'
using i

        mlApplyMeta qiq'.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H2" ∶ q,
--------------------------------------
q
using i

        mlExact "H2".
    -
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
p' or q' ---> p or q
using i
 mlIntro "H0".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H0" ∶ p' or q',
--------------------------------------
p or q
using i

      mlDestructOr "H0" as "H1" "H2".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ p',
--------------------------------------
p or q
using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H2" ∶ q',
--------------------------------------
p or q
using i

      mlLeft.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ p',
--------------------------------------
p
using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H2" ∶ q',
--------------------------------------
p or q
using i

      +
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ p',
--------------------------------------
p
using i
 mlApplyMeta p'ip.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H1" ∶ p',
--------------------------------------
p'
using i

        mlExact "H1".
      +
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H2" ∶ q',
--------------------------------------
p or q
using i
 mlRight.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H2" ∶ q',
--------------------------------------
q
using i

        mlApplyMeta q'iq.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ
"H2" ∶ q',
--------------------------------------
q'
using i

        mlExact "H2". 
  Defined.

Close Scope string_scope.
Close Scope list_scope.
Close Scope ml_scope.